parses an XML Schema, allows access to it's data, other utility methods. More...

Inheritance diagram for nusoap_xmlschema:

Collaboration diagram for nusoap_xmlschema:

Public Member Functions
	__construct ($schema='', $xml='', $namespaces=array())
	constructor More...

	parseFile ($xml, $type)
	parse an XML file More...

	parseString ($xml, $type)
	parse an XML string More...

	CreateTypeName ($ename)
	gets a type name for an unnamed type More...

	schemaStartElement ($parser, $name, $attrs)
	start-element handler More...

	schemaEndElement ($parser, $name)
	end-element handler More...

	schemaCharacterData ($parser, $data)
	element content handler More...

	serializeSchema ()
	serialize the schema More...

	xdebug ($string)
	adds debug data to the clas level debug string More...

	getPHPType ($type, $ns)
	get the PHP type of a user defined type in the schema PHP type is kind of a misnomer since it actually returns 'struct' for assoc. More...

	getTypeDef ($type)
	returns an associative array of information about a given type returns false if no type exists by the given name More...

	serializeTypeDef ($type)
	returns a sample serialization of a given type, or false if no type by the given name More...

	typeToForm ($name, $type)
	returns HTML form elements that allow a user to enter values for creating an instance of the given type. More...

	addComplexType ($name, $typeClass='complexType', $phpType='array', $compositor='', $restrictionBase='', $elements=array(), $attrs=array(), $arrayType='')
	adds a complex type to the schema More...

	addSimpleType ($name, $restrictionBase='', $typeClass='simpleType', $phpType='scalar', $enumeration=array())
	adds a simple type to the schema More...

	addElement ($attrs)
	adds an element to the schema More...

Public Member Functions inherited from nusoap_base
	__construct ()
	constructor More...

	getGlobalDebugLevel ()
	gets the global debug level, which applies to future instances More...

	setGlobalDebugLevel ($level)
	sets the global debug level, which applies to future instances More...

	getDebugLevel ()
	gets the debug level for this instance More...

	setDebugLevel ($level)
	sets the debug level for this instance More...

	debug ($string)
	adds debug data to the instance debug string with formatting More...

	appendDebug ($string)
	adds debug data to the instance debug string without formatting More...

	clearDebug ()
	clears the current debug data for this instance More...

&	getDebug ()
	gets the current debug data for this instance More...

&	getDebugAsXMLComment ()
	gets the current debug data for this instance as an XML comment this may change the contents of the debug data More...

	expandEntities ($val)
	expands entities, e.g. More...

	getError ()
	returns error string if present More...

	setError ($str)
	sets error string More...

	isArraySimpleOrStruct ($val)
	detect if array is a simple array or a struct (associative array) More...

	serialize_val ($val, $name=false, $type=false, $name_ns=false, $type_ns=false, $attributes=false, $use='encoded', $soapval=false)
	serializes PHP values in accordance w/ section 5. More...

	serializeEnvelope ($body, $headers=false, $namespaces=array(), $style='rpc', $use='encoded', $encodingStyle='http://schemas.xmlsoap.org/soap/encoding/')
	serializes a message More...

	formatDump ($str)
	formats a string to be inserted into an HTML stream More...

	contractQname ($qname)
	contracts (changes namespace to prefix) a qualified name More...

	expandQname ($qname)
	expands (changes prefix to namespace) a qualified name More...

	getLocalPart ($str)
	returns the local part of a prefixed string returns the original string, if not prefixed More...

	getPrefix ($str)
	returns the prefix part of a prefixed string returns false, if not prefixed More...

	getNamespaceFromPrefix ($prefix)
	pass it a prefix, it returns a namespace More...

	getPrefixFromNamespace ($ns)
	returns the prefix for a given namespace (or prefix) or false if no prefixes registered for the given namespace More...

	getmicrotime ()
	returns the time in ODBC canonical form with microseconds More...

	varDump ($data)
	Returns a string with the output of var_dump. More...

	__toString ()
	represents the object as a string More...

Data Fields
	$schema = ''

	$xml = ''

	$enclosingNamespaces

	$schemaInfo = array()

	$schemaTargetNamespace = ''

	$attributes = array()

	$complexTypes = array()

	$complexTypeStack = array()

	$currentComplexType = null

	$elements = array()

	$elementStack = array()

	$currentElement = null

	$simpleTypes = array()

	$simpleTypeStack = array()

	$currentSimpleType = null

	$imports = array()

	$parser

	$position = 0

	$depth = 0

	$depth_array = array()

	$message = array()

	$defaultNamespace = array()

Data Fields inherited from nusoap_base
	$title = 'NuSOAP'

	$version = '0.7.3'

	$revision = '$Revision$'

	$error_str = ''

	$debug_str = ''

	$charencoding = true

	$debugLevel

	$XMLSchemaVersion = 'http://www.w3.org/2001/XMLSchema'

	$soap_defencoding = 'UTF-8'

	$namespaces

	$usedNamespaces = array()

	$typemap

	$xmlEntities

Detailed Description

parses an XML Schema, allows access to it's data, other utility methods.

imperfect, no validation... yet, but quite functional.

Author: Dietrich Ayala dietr.nosp@m.ich@.nosp@m.ganx4.nosp@m..com; Scott Nichol snich.nosp@m.ol@u.nosp@m.sers..nosp@m.sour.nosp@m.cefor.nosp@m.ge.n.nosp@m.et

Version: $Id$ public

Definition at line 1085 of file nusoap.php.

Constructor & Destructor Documentation

◆ __construct()

nusoap_xmlschema::__construct	(	$schema = `''`,
		$xml = `''`,
		$namespaces = `array()`
	)

constructor

Parameters

string	$schema	schema document URI
string	$xml	xml document URI
string	$namespaces	namespaces defined in enclosing XML public

Definition at line 1124 of file nusoap.php.

References nusoap_base\$namespaces, ILIAS\GlobalScreen\Provider\__construct(), and nusoap_base\debug().

     {
         parent::__construct();
         $this->debug('nusoap_xmlschema class instantiated, inside constructor');
         // files
         $this->schema = $schema;
         $this->xml = $xml;
 
         // namespaces
         $this->enclosingNamespaces = $namespaces;
         $this->namespaces = array_merge($this->namespaces, $namespaces);
 
         // parse schema file
         if ($schema != '') {
             $this->debug('initial schema file: ' . $schema);
             $this->parseFile($schema, 'schema');
         }
 
         // parse xml file
         if ($xml != '') {
             $this->debug('initial xml file: ' . $xml);
             $this->parseFile($xml, 'xml');
         }
     }

Here is the call graph for this function:

Member Function Documentation

◆ addComplexType()

nusoap_xmlschema::addComplexType	(	$name,
		$typeClass = `'complexType'`,
		$phpType = `'array'`,
		$compositor = `''`,
		$restrictionBase = `''`,
		$elements = `array()`,
		$attrs = `array()`,
		$arrayType = `''`
	)

adds a complex type to the schema

example: array

addType( 'ArrayOfstring', 'complexType', 'array', '', 'SOAP-ENC:Array', array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'string[]'), 'xsd:string' );

example: PHP associative array ( SOAP Struct )

addType( 'SOAPStruct', 'complexType', 'struct', 'all', array('myVar'=> array('name'=>'myVar','type'=>'string') );

Parameters

name
typeClass	(complexType\|simpleType\|attribute)
phpType	currently supported are array and struct (php assoc array)
compositor	(all\|sequence\|choice)
restrictionBase	namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
elements	= array ( name = array(name=>'',type=>'') )
attrs	= array( array( 'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType", "http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]" ) )
arrayType	namespace:name (http://www.w3.org/2001/XMLSchema:string) public

See also: getTypeDef

Definition at line 1949 of file nusoap.php.

References nusoap_base\appendDebug(), and nusoap_base\varDump().

     {
         $this->complexTypes[$name] = array(
         'name' => $name,
         'typeClass' => $typeClass,
         'phpType' => $phpType,
         'compositor' => $compositor,
         'restrictionBase' => $restrictionBase,
         'elements' => $elements,
         'attrs' => $attrs,
         'arrayType' => $arrayType
         );
 
         $this->xdebug("addComplexType $name:");
         $this->appendDebug($this->varDump($this->complexTypes[$name]));
     }

Here is the call graph for this function:

◆ addElement()

nusoap_xmlschema::addElement ( $attrs )

adds an element to the schema

Parameters

array $attrs attributes that must include name and type

See also: nusoap_xmlschema public

Definition at line 1999 of file nusoap.php.

References nusoap_base\appendDebug(), nusoap_base\getPrefix(), and nusoap_base\varDump().

     {
         if (! $this->getPrefix($attrs['type'])) {
             $attrs['type'] = $this->schemaTargetNamespace . ':' . $attrs['type'];
         }
         $this->elements[ $attrs['name'] ] = $attrs;
         $this->elements[ $attrs['name'] ]['typeClass'] = 'element';
 
         $this->xdebug("addElement " . $attrs['name']);
         $this->appendDebug($this->varDump($this->elements[ $attrs['name'] ]));
     }

Here is the call graph for this function:

◆ addSimpleType()

nusoap_xmlschema::addSimpleType	(	$name,
		$restrictionBase = `''`,
		$typeClass = `'simpleType'`,
		$phpType = `'scalar'`,
		$enumeration = `array()`
	)

adds a simple type to the schema

Parameters

string	$name
string	$restrictionBase	namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
string	$typeClass	(should always be simpleType)
string	$phpType	(should always be scalar)
array	$enumeration	array of values public

See also: nusoap_xmlschema; getTypeDef

Definition at line 1978 of file nusoap.php.

References nusoap_base\appendDebug(), and nusoap_base\varDump().

     {
         $this->simpleTypes[$name] = array(
         'name' => $name,
         'typeClass' => $typeClass,
         'phpType' => $phpType,
         'type' => $restrictionBase,
         'enumeration' => $enumeration
         );
 
         $this->xdebug("addSimpleType $name:");
         $this->appendDebug($this->varDump($this->simpleTypes[$name]));
     }

Here is the call graph for this function:

◆ CreateTypeName()

nusoap_xmlschema::CreateTypeName ( $ename )

gets a type name for an unnamed type

Parameters

string Element name

Returns: string A type name for an unnamed type private

Definition at line 1229 of file nusoap.php.

References $scope.

     {
         $scope = '';
         for ($i = 0; $i < count($this->complexTypeStack); $i++) {
             $scope .= $this->complexTypeStack[$i] . '_';
         }
         return $scope . $ename . '_ContainedType';
     }

◆ getPHPType()

nusoap_xmlschema::getPHPType	(	$type,
		$ns
	)

get the PHP type of a user defined type in the schema PHP type is kind of a misnomer since it actually returns 'struct' for assoc.

arrays returns false if no type exists, or not w/ the given namespace else returns a string that is either a native php type, or 'struct'

Parameters

string	$type	name of defined type
string	$ns	namespace of type

Returns: mixed public

Deprecated:

Definition at line 1728 of file nusoap.php.

     {
         if (isset($this->typemap[$ns][$type])) {
             //print "found type '$type' and ns $ns in typemap<br>";
             return $this->typemap[$ns][$type];
         } elseif (isset($this->complexTypes[$type])) {
             //print "getting type '$type' and ns $ns from complexTypes array<br>";
             return $this->complexTypes[$type]['phpType'];
         }
         return false;
     }

◆ getTypeDef()

nusoap_xmlschema::getTypeDef ( $type )

returns an associative array of information about a given type returns false if no type exists by the given name

For a complexType typeDef = array( 'restrictionBase' => '', 'phpType' => '', 'compositor' => '(sequence|all)', 'elements' => array(), // refs to elements array 'attrs' => array() // refs to attributes array ... and so on (see addComplexType) )

For simpleType or element, the array has different keys.

Parameters

string $type

Returns: mixed public

See also: addComplexType; addSimpleType; addElement

Definition at line 1762 of file nusoap.php.

References nusoap_base\varDump().

     {
         //$this->debug("in getTypeDef for type $type");
         if (substr($type, -1) == '^') {
             $is_element = 1;
             $type = substr($type, 0, -1);
         } else {
             $is_element = 0;
         }
 
         if ((! $is_element) && isset($this->complexTypes[$type])) {
             $this->xdebug("in getTypeDef, found complexType $type");
             return $this->complexTypes[$type];
         } elseif ((! $is_element) && isset($this->simpleTypes[$type])) {
             $this->xdebug("in getTypeDef, found simpleType $type");
             if (!isset($this->simpleTypes[$type]['phpType'])) {
                 // get info for type to tack onto the simple type
                 // TODO: can this ever really apply (i.e. what is a simpleType really?)
                 $uqType = substr($this->simpleTypes[$type]['type'], strrpos($this->simpleTypes[$type]['type'], ':') + 1);
                 $ns = substr($this->simpleTypes[$type]['type'], 0, strrpos($this->simpleTypes[$type]['type'], ':'));
                 $etype = $this->getTypeDef($uqType);
                 if ($etype) {
                     $this->xdebug("in getTypeDef, found type for simpleType $type:");
                     $this->xdebug($this->varDump($etype));
                     if (isset($etype['phpType'])) {
                         $this->simpleTypes[$type]['phpType'] = $etype['phpType'];
                     }
                     if (isset($etype['elements'])) {
                         $this->simpleTypes[$type]['elements'] = $etype['elements'];
                     }
                 }
             }
             return $this->simpleTypes[$type];
         } elseif (isset($this->elements[$type])) {
             $this->xdebug("in getTypeDef, found element $type");
             if (!isset($this->elements[$type]['phpType'])) {
                 // get info for type to tack onto the element
                 $uqType = substr($this->elements[$type]['type'], strrpos($this->elements[$type]['type'], ':') + 1);
                 $ns = substr($this->elements[$type]['type'], 0, strrpos($this->elements[$type]['type'], ':'));
                 $etype = $this->getTypeDef($uqType);
                 if ($etype) {
                     $this->xdebug("in getTypeDef, found type for element $type:");
                     $this->xdebug($this->varDump($etype));
                     if (isset($etype['phpType'])) {
                         $this->elements[$type]['phpType'] = $etype['phpType'];
                     }
                     if (isset($etype['elements'])) {
                         $this->elements[$type]['elements'] = $etype['elements'];
                     }
                 } elseif ($ns == 'http://www.w3.org/2001/XMLSchema') {
                     $this->xdebug("in getTypeDef, element $type is an XSD type");
                     $this->elements[$type]['phpType'] = 'scalar';
                 }
             }
             return $this->elements[$type];
         } elseif (isset($this->attributes[$type])) {
             $this->xdebug("in getTypeDef, found attribute $type");
             return $this->attributes[$type];
         } elseif (preg_match('/_ContainedType$/', $type)) {
             $this->xdebug("in getTypeDef, have an untyped element $type");
             $typeDef['typeClass'] = 'simpleType';
             $typeDef['phpType'] = 'scalar';
             $typeDef['type'] = 'http://www.w3.org/2001/XMLSchema:string';
             return $typeDef;
         }
         $this->xdebug("in getTypeDef, did not find $type");
         return false;
     }

Here is the call graph for this function:

◆ parseFile()

nusoap_xmlschema::parseFile	(	$xml,
		$type
	)

parse an XML file

Parameters

string	$xml	path/URL to XML file
string	$type	(schema \| xml)

Returns: boolean public

Definition at line 1157 of file nusoap.php.

References nusoap_base\debug(), and nusoap_base\setError().

     {
         // parse xml file
         if ($xml != "") {
             $xmlStr = @join("", @file($xml));
             if ($xmlStr == "") {
                 $msg = 'Error reading XML from ' . $xml;
                 $this->setError($msg);
                 $this->debug($msg);
                 return false;
             } else {
                 $this->debug("parsing $xml");
                 $this->parseString($xmlStr, $type);
                 $this->debug("done parsing $xml");
                 return true;
             }
         }
         return false;
     }

Here is the call graph for this function:

◆ parseString()

nusoap_xmlschema::parseString	(	$xml,
		$type
	)

parse an XML string

Parameters

string	$xml	path or URL
string	$type	(schema\|xml) private

Definition at line 1184 of file nusoap.php.

References nusoap_base\debug(), and nusoap_base\setError().

     {
         // parse xml string
         if ($xml != "") {
             // Create an XML parser.
             $this->parser = xml_parser_create();
             // Set the options for parsing the XML data.
             xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
 
             // Set the element handlers for the parser.
             if ($type == "schema") {
                 xml_set_element_handler($this->parser, $this->schemaStartElement(...), $this->schemaEndElement(...));
                 xml_set_character_data_handler($this->parser, $this->schemaCharacterData(...));
             } elseif ($type == "xml") {
                 xml_set_element_handler($this->parser, $this->xmlStartElement(...), $this->xmlEndElement(...));
                 xml_set_character_data_handler($this->parser, $this->xmlCharacterData(...));
             }
 
             // Parse the XML file.
             if (!xml_parse($this->parser, $xml, true)) {
                 // Display an error message.
                 $errstr = sprintf(
                     'XML error parsing XML schema on line %d: %s',
                     xml_get_current_line_number($this->parser),
                     xml_error_string(xml_get_error_code($this->parser))
                 );
                 $this->debug($errstr);
                 $this->debug("XML payload:\n" . $xml);
                 $this->setError($errstr);
             }
 
             xml_parser_free($this->parser);
         } else {
             $this->debug('no xml passed to parseString()!!');
             $this->setError('no xml passed to parseString()!!');
         }
     }

Here is the call graph for this function:

◆ schemaCharacterData()

nusoap_xmlschema::schemaCharacterData	(	$parser,
		$data
	)

element content handler

Parameters

string	$parser	XML parser object
string	$data	element content private

Definition at line 1582 of file nusoap.php.

References $data.

     {
         $pos = $this->depth_array[$this->depth - 1];
         $this->message[$pos]['cdata'] .= $data;
     }

◆ schemaEndElement()

nusoap_xmlschema::schemaEndElement	(	$parser,
		$name
	)

end-element handler

Parameters

string	$parser	XML parser object
string	$name	element name private

Definition at line 1544 of file nusoap.php.

References nusoap_base\getLocalPart(), and nusoap_base\getPrefix().

     {
         // bring depth down a notch
         $this->depth--;
         // position of current element is equal to the last value left in depth_array for my depth
         if (isset($this->depth_array[$this->depth])) {
             $pos = $this->depth_array[$this->depth];
         }
         // get element prefix
         if ($prefix = $this->getPrefix($name)) {
             // get unqualified name
             $name = $this->getLocalPart($name);
         } else {
             $prefix = '';
         }
         // move on...
         if ($name == 'complexType') {
             $this->xdebug('done processing complexType ' . ($this->currentComplexType ? $this->currentComplexType : '(unknown)'));
             $this->currentComplexType = array_pop($this->complexTypeStack);
             //$this->currentElement = false;
         }
         if ($name == 'element') {
             $this->xdebug('done processing element ' . ($this->currentElement ? $this->currentElement : '(unknown)'));
             $this->currentElement = array_pop($this->elementStack);
         }
         if ($name == 'simpleType') {
             $this->xdebug('done processing simpleType ' . ($this->currentSimpleType ? $this->currentSimpleType : '(unknown)'));
             $this->currentSimpleType = array_pop($this->simpleTypeStack);
         }
     }

Here is the call graph for this function:

◆ schemaStartElement()

nusoap_xmlschema::schemaStartElement	(	$parser,
		$name,
		$attrs
	)

start-element handler

Parameters

string	$parser	XML parser object
string	$name	element name
string	$attrs	associative array of attributes private

Definition at line 1246 of file nusoap.php.

References nusoap_base\appendDebug(), nusoap_base\expandQname(), nusoap_base\getLocalPart(), nusoap_base\getNamespaceFromPrefix(), nusoap_base\getPrefix(), nusoap_base\getPrefixFromNamespace(), and nusoap_base\varDump().

     {
 
         // position in the total number of elements, starting from 0
         $pos = $this->position++;
         $depth = $this->depth++;
         // set self as current value for this depth
         $this->depth_array[$depth] = $pos;
         $this->message[$pos] = array('cdata' => '');
         if ($depth > 0) {
             $this->defaultNamespace[$pos] = $this->defaultNamespace[$this->depth_array[$depth - 1]];
         } else {
             $this->defaultNamespace[$pos] = false;
         }
 
         // get element prefix
         if ($prefix = $this->getPrefix($name)) {
             // get unqualified name
             $name = $this->getLocalPart($name);
         } else {
             $prefix = '';
         }
 
         // loop thru attributes, expanding, and registering namespace declarations
         if (count($attrs) > 0) {
             foreach ($attrs as $k => $v) {
                 // if ns declarations, add to class level array of valid namespaces
                 if (preg_match('/^xmlns/', $k)) {
                     //$this->xdebug("$k: $v");
                     //$this->xdebug('ns_prefix: '.$this->getPrefix($k));
                     if ($ns_prefix = substr(strrchr($k, ':'), 1)) {
                         //$this->xdebug("Add namespace[$ns_prefix] = $v");
                         $this->namespaces[$ns_prefix] = $v;
                     } else {
                         $this->defaultNamespace[$pos] = $v;
                         if (! $this->getPrefixFromNamespace($v)) {
                             $this->namespaces['ns' . (count($this->namespaces) + 1)] = $v;
                         }
                     }
                     if ($v == 'http://www.w3.org/2001/XMLSchema' || $v == 'http://www.w3.org/1999/XMLSchema' || $v == 'http://www.w3.org/2000/10/XMLSchema') {
                         $this->XMLSchemaVersion = $v;
                         $this->namespaces['xsi'] = $v . '-instance';
                     }
                 }
             }
             foreach ($attrs as $k => $v) {
                 // expand each attribute
                 $k = strpos($k, ':') ? $this->expandQname($k) : $k;
                 $v = strpos($v, ':') ? $this->expandQname($v) : $v;
                 $eAttrs[$k] = $v;
             }
             $attrs = $eAttrs;
         } else {
             $attrs = array();
         }
         // find status, register data
         switch ($name) {
             case 'all':                 // (optional) compositor content for a complexType
             case 'choice':
             case 'group':
             case 'sequence':
                 //$this->xdebug("compositor $name for currentComplexType: $this->currentComplexType and currentElement: $this->currentElement");
                 $this->complexTypes[$this->currentComplexType]['compositor'] = $name;
                 //if($name == 'all' || $name == 'sequence'){
                 //      $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
                 //}
                 break;
             case 'attribute':   // complexType attribute
                 //$this->xdebug("parsing attribute $attrs[name] $attrs[ref] of value: ".$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']);
                 $this->xdebug("parsing attribute:");
                 $this->appendDebug($this->varDump($attrs));
                 if (!isset($attrs['form'])) {
                     $attrs['form'] = $this->schemaInfo['attributeFormDefault'];
                 }
                 if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
                     $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
                     if (!strpos($v, ':')) {
                         // no namespace in arrayType attribute value...
                         if ($this->defaultNamespace[$pos]) {
                             // ...so use the default
                             $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'] = $this->defaultNamespace[$pos] . ':' . $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
                         }
                     }
                 }
                 if (isset($attrs['name'])) {
                     $this->attributes[$attrs['name']] = $attrs;
                     $aname = $attrs['name'];
                 } elseif (isset($attrs['ref']) && $attrs['ref'] == 'http://schemas.xmlsoap.org/soap/encoding/:arrayType') {
                     if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
                         $aname = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
                     } else {
                         $aname = '';
                     }
                 } elseif (isset($attrs['ref'])) {
                     $aname = $attrs['ref'];
                     $this->attributes[$attrs['ref']] = $attrs;
                 }
 
                 if ($this->currentComplexType) {        // This should *always* be
                     $this->complexTypes[$this->currentComplexType]['attrs'][$aname] = $attrs;
                 }
                 // arrayType attribute
                 if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']) || $this->getLocalPart($aname) == 'arrayType') {
                     $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
                     $prefix = $this->getPrefix($aname);
                     if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
                         $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
                     } else {
                         $v = '';
                     }
                     if (strpos($v, '[,]')) {
                         $this->complexTypes[$this->currentComplexType]['multidimensional'] = true;
                     }
                     $v = substr($v, 0, strpos($v, '[')); // clip the []
                     if (!strpos($v, ':') && isset($this->typemap[$this->XMLSchemaVersion][$v])) {
                         $v = $this->XMLSchemaVersion . ':' . $v;
                     }
                     $this->complexTypes[$this->currentComplexType]['arrayType'] = $v;
                 }
                 break;
             case 'complexContent':      // (optional) content for a complexType
                 break;
             case 'complexType':
                 array_push($this->complexTypeStack, $this->currentComplexType);
                 if (isset($attrs['name'])) {
                     // TODO: what is the scope of named complexTypes that appear
                     //       nested within other c complexTypes?
                     $this->xdebug('processing named complexType ' . $attrs['name']);
                     //$this->currentElement = false;
                     $this->currentComplexType = $attrs['name'];
                     $this->complexTypes[$this->currentComplexType] = $attrs;
                     $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';
                     // This is for constructs like
                     //           <complexType name="ListOfString" base="soap:Array">
                     //                <sequence>
                     //                    <element name="string" type="xsd:string"
                     //                        minOccurs="0" maxOccurs="unbounded" />
                     //                </sequence>
                     //            </complexType>
                     if (isset($attrs['base']) && preg_match('/:Array$/', $attrs['base'])) {
                         $this->xdebug('complexType is unusual array');
                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
                     } else {
                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
                     }
                 } else {
                     $name = $this->CreateTypeName($this->currentElement);
                     $this->xdebug('processing unnamed complexType for element ' . $this->currentElement . ' named ' . $name);
                     $this->currentComplexType = $name;
                     //$this->currentElement = false;
                     $this->complexTypes[$this->currentComplexType] = $attrs;
                     $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';
                     // This is for constructs like
                     //           <complexType name="ListOfString" base="soap:Array">
                     //                <sequence>
                     //                    <element name="string" type="xsd:string"
                     //                        minOccurs="0" maxOccurs="unbounded" />
                     //                </sequence>
                     //            </complexType>
                     if (isset($attrs['base']) && preg_match('/:Array$/', $attrs['base'])) {
                         $this->xdebug('complexType is unusual array');
                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
                     } else {
                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
                     }
                 }
                 break;
             case 'element':
                 array_push($this->elementStack, $this->currentElement);
                 if (!isset($attrs['form'])) {
                     $attrs['form'] = $this->schemaInfo['elementFormDefault'];
                 }
                 if (isset($attrs['type'])) {
                     $this->xdebug("processing typed element " . $attrs['name'] . " of type " . $attrs['type']);
                     if (! $this->getPrefix($attrs['type'])) {
                         if ($this->defaultNamespace[$pos]) {
                             $attrs['type'] = $this->defaultNamespace[$pos] . ':' . $attrs['type'];
                             $this->xdebug('used default namespace to make type ' . $attrs['type']);
                         }
                     }
                     // This is for constructs like
                     //           <complexType name="ListOfString" base="soap:Array">
                     //                <sequence>
                     //                    <element name="string" type="xsd:string"
                     //                        minOccurs="0" maxOccurs="unbounded" />
                     //                </sequence>
                     //            </complexType>
                     if ($this->currentComplexType && $this->complexTypes[$this->currentComplexType]['phpType'] == 'array') {
                         $this->xdebug('arrayType for unusual array is ' . $attrs['type']);
                         $this->complexTypes[$this->currentComplexType]['arrayType'] = $attrs['type'];
                     }
                     $this->currentElement = $attrs['name'];
                     $ename = $attrs['name'];
                 } elseif (isset($attrs['ref'])) {
                     $this->xdebug("processing element as ref to " . $attrs['ref']);
                     $this->currentElement = "ref to " . $attrs['ref'];
                     $ename = $this->getLocalPart($attrs['ref']);
                 } else {
                     $type = $this->CreateTypeName($this->currentComplexType . '_' . $attrs['name']);
                     $this->xdebug("processing untyped element " . $attrs['name'] . ' type ' . $type);
                     $this->currentElement = $attrs['name'];
                     $attrs['type'] = $this->schemaTargetNamespace . ':' . $type;
                     $ename = $attrs['name'];
                 }
                 if (isset($ename) && $this->currentComplexType) {
                     $this->xdebug("add element $ename to complexType $this->currentComplexType");
                     $this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs;
                 } elseif (!isset($attrs['ref'])) {
                     $this->xdebug("add element $ename to elements array");
                     $this->elements[ $attrs['name'] ] = $attrs;
                     $this->elements[ $attrs['name'] ]['typeClass'] = 'element';
                 }
                 break;
             case 'enumeration': //      restriction value list member
                 $this->xdebug('enumeration ' . $attrs['value']);
                 if ($this->currentSimpleType) {
                     $this->simpleTypes[$this->currentSimpleType]['enumeration'][] = $attrs['value'];
                 } elseif ($this->currentComplexType) {
                     $this->complexTypes[$this->currentComplexType]['enumeration'][] = $attrs['value'];
                 }
                 break;
             case 'extension':   // simpleContent or complexContent type extension
                 $this->xdebug('extension ' . $attrs['base']);
                 if ($this->currentComplexType) {
                     $this->complexTypes[$this->currentComplexType]['extensionBase'] = $attrs['base'];
                 }
                 break;
             case 'import':
                 if (isset($attrs['schemaLocation'])) {
                     //$this->xdebug('import namespace ' . $attrs['namespace'] . ' from ' . $attrs['schemaLocation']);
                     $this->imports[$attrs['namespace']][] = array('location' => $attrs['schemaLocation'], 'loaded' => false);
                 } else {
                     //$this->xdebug('import namespace ' . $attrs['namespace']);
                     $this->imports[$attrs['namespace']][] = array('location' => '', 'loaded' => true);
                     if (! $this->getPrefixFromNamespace($attrs['namespace'])) {
                         $this->namespaces['ns' . (count($this->namespaces) + 1)] = $attrs['namespace'];
                     }
                 }
                 break;
             case 'list':        // simpleType value list
                 break;
             case 'restriction': // simpleType, simpleContent or complexContent value restriction
                 $this->xdebug('restriction ' . $attrs['base']);
                 if ($this->currentSimpleType) {
                     $this->simpleTypes[$this->currentSimpleType]['type'] = $attrs['base'];
                 } elseif ($this->currentComplexType) {
                     $this->complexTypes[$this->currentComplexType]['restrictionBase'] = $attrs['base'];
                     if (strstr($attrs['base'], ':') == ':Array') {
                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
                     }
                 }
                 break;
             case 'schema':
                 $this->schemaInfo = $attrs;
                 $this->schemaInfo['schemaVersion'] = $this->getNamespaceFromPrefix($prefix);
                 if (isset($attrs['targetNamespace'])) {
                     $this->schemaTargetNamespace = $attrs['targetNamespace'];
                 }
                 if (!isset($attrs['elementFormDefault'])) {
                     $this->schemaInfo['elementFormDefault'] = 'unqualified';
                 }
                 if (!isset($attrs['attributeFormDefault'])) {
                     $this->schemaInfo['attributeFormDefault'] = 'unqualified';
                 }
                 break;
             case 'simpleContent':       // (optional) content for a complexType
                 break;
             case 'simpleType':
                 array_push($this->simpleTypeStack, $this->currentSimpleType);
                 if (isset($attrs['name'])) {
                     $this->xdebug("processing simpleType for name " . $attrs['name']);
                     $this->currentSimpleType = $attrs['name'];
                     $this->simpleTypes[ $attrs['name'] ] = $attrs;
                     $this->simpleTypes[ $attrs['name'] ]['typeClass'] = 'simpleType';
                     $this->simpleTypes[ $attrs['name'] ]['phpType'] = 'scalar';
                 } else {
                     $name = $this->CreateTypeName($this->currentComplexType . '_' . $this->currentElement);
                     $this->xdebug('processing unnamed simpleType for element ' . $this->currentElement . ' named ' . $name);
                     $this->currentSimpleType = $name;
                     //$this->currentElement = false;
                     $this->simpleTypes[$this->currentSimpleType] = $attrs;
                     $this->simpleTypes[$this->currentSimpleType]['phpType'] = 'scalar';
                 }
                 break;
             case 'union':       // simpleType type list
                 break;
             default:
                 //$this->xdebug("do not have anything to do for element $name");
         }
     }

Here is the call graph for this function:

◆ serializeSchema()

nusoap_xmlschema::serializeSchema ( )

serialize the schema

public

Definition at line 1593 of file nusoap.php.

References Vendor\Package\$a, Vendor\Package\$e, and nusoap_base\getPrefixFromNamespace().

     {
         $schemaPrefix = $this->getPrefixFromNamespace($this->XMLSchemaVersion);
         $xml = '';
         // imports
         if (sizeof($this->imports) > 0) {
             foreach ($this->imports as $ns => $list) {
                 foreach ($list as $ii) {
                     if ($ii['location'] != '') {
                         $xml .= " <$schemaPrefix:import location=\"" . $ii['location'] . '" namespace="' . $ns . "\" />\n";
                     } else {
                         $xml .= " <$schemaPrefix:import namespace=\"" . $ns . "\" />\n";
                     }
                 }
             }
         }
         // complex types
         foreach ($this->complexTypes as $typeName => $attrs) {
             $contentStr = '';
             // serialize child elements
             if (isset($attrs['elements']) && (count($attrs['elements']) > 0)) {
                 foreach ($attrs['elements'] as $element => $eParts) {
                     if (isset($eParts['ref'])) {
                         $contentStr .= "   <$schemaPrefix:element ref=\"$element\"/>\n";
                     } else {
                         $contentStr .= "   <$schemaPrefix:element name=\"$element\" type=\"" . $this->contractQName($eParts['type']) . "\"";
                         foreach ($eParts as $aName => $aValue) {
                             // handle, e.g., abstract, default, form, minOccurs, maxOccurs, nillable
                             if ($aName != 'name' && $aName != 'type') {
                                 $contentStr .= " $aName=\"$aValue\"";
                             }
                         }
                         $contentStr .= "/>\n";
                     }
                 }
                 // compositor wraps elements
                 if (isset($attrs['compositor']) && ($attrs['compositor'] != '')) {
                     $contentStr = "  <$schemaPrefix:$attrs[compositor]>\n" . $contentStr . "  </$schemaPrefix:$attrs[compositor]>\n";
                 }
             }
             // attributes
             if (isset($attrs['attrs']) && (count($attrs['attrs']) >= 1)) {
                 foreach ($attrs['attrs'] as $attr => $aParts) {
                     $contentStr .= "    <$schemaPrefix:attribute";
                     foreach ($aParts as $a => $v) {
                         if ($a == 'ref' || $a == 'type') {
                             $contentStr .= " $a=\"" . $this->contractQName($v) . '"';
                         } elseif ($a == 'http://schemas.xmlsoap.org/wsdl/:arrayType') {
                             $this->usedNamespaces['wsdl'] = $this->namespaces['wsdl'];
                             $contentStr .= ' wsdl:arrayType="' . $this->contractQName($v) . '"';
                         } else {
                             $contentStr .= " $a=\"$v\"";
                         }
                     }
                     $contentStr .= "/>\n";
                 }
             }
             // if restriction
             if (isset($attrs['restrictionBase']) && $attrs['restrictionBase'] != '') {
                 $contentStr = "   <$schemaPrefix:restriction base=\"" . $this->contractQName($attrs['restrictionBase']) . "\">\n" . $contentStr . "   </$schemaPrefix:restriction>\n";
                 // complex or simple content
                 if ((isset($attrs['elements']) && count($attrs['elements']) > 0) || (isset($attrs['attrs']) && count($attrs['attrs']) > 0)) {
                     $contentStr = "  <$schemaPrefix:complexContent>\n" . $contentStr . "  </$schemaPrefix:complexContent>\n";
                 }
             }
             // finalize complex type
             if ($contentStr != '') {
                 $contentStr = " <$schemaPrefix:complexType name=\"$typeName\">\n" . $contentStr . " </$schemaPrefix:complexType>\n";
             } else {
                 $contentStr = " <$schemaPrefix:complexType name=\"$typeName\"/>\n";
             }
             $xml .= $contentStr;
         }
         // simple types
         if (isset($this->simpleTypes) && count($this->simpleTypes) > 0) {
             foreach ($this->simpleTypes as $typeName => $eParts) {
                 $xml .= " <$schemaPrefix:simpleType name=\"$typeName\">\n  <$schemaPrefix:restriction base=\"" . $this->contractQName($eParts['type']) . "\">\n";
                 if (isset($eParts['enumeration'])) {
                     foreach ($eParts['enumeration'] as $e) {
                         $xml .= "  <$schemaPrefix:enumeration value=\"$e\"/>\n";
                     }
                 }
                 $xml .= "  </$schemaPrefix:restriction>\n </$schemaPrefix:simpleType>";
             }
         }
         // elements
         if (isset($this->elements) && count($this->elements) > 0) {
             foreach ($this->elements as $element => $eParts) {
                 $xml .= " <$schemaPrefix:element name=\"$element\" type=\"" . $this->contractQName($eParts['type']) . "\"/>\n";
             }
         }
         // attributes
         if (isset($this->attributes) && count($this->attributes) > 0) {
             foreach ($this->attributes as $attr => $aParts) {
                 $xml .= " <$schemaPrefix:attribute name=\"$attr\" type=\"" . $this->contractQName($aParts['type']) . "\"\n/>";
             }
         }
         // finish 'er up
         $attr = '';
         foreach ($this->schemaInfo as $k => $v) {
             if ($k == 'elementFormDefault' || $k == 'attributeFormDefault') {
                 $attr .= " $k=\"$v\"";
             }
         }
         $el = "<$schemaPrefix:schema$attr targetNamespace=\"$this->schemaTargetNamespace\"\n";
         foreach (array_diff($this->usedNamespaces, $this->enclosingNamespaces) as $nsp => $ns) {
             $el .= " xmlns:$nsp=\"$ns\"";
         }
         $xml = $el . ">\n" . $xml . "</$schemaPrefix:schema>\n";
         return $xml;
     }

Here is the call graph for this function:

◆ serializeTypeDef()

nusoap_xmlschema::serializeTypeDef ( $type )

returns a sample serialization of a given type, or false if no type by the given name

Parameters

string $type name of type

Returns: mixed public

Deprecated:

Definition at line 1839 of file nusoap.php.

References $data.

     {
         //print "in sTD() for type $type<br>";
         if ($typeDef = $this->getTypeDef($type)) {
             $str .= '<' . $type;
             if (is_array($typeDef['attrs'])) {
                 foreach ($typeDef['attrs'] as $attName => $data) {
                     $str .= " $attName=\"{type = " . $data['type'] . "}\"";
                 }
             }
             $str .= " xmlns=\"" . $this->schema['targetNamespace'] . "\"";
             if (count($typeDef['elements']) > 0) {
                 $str .= ">";
                 foreach ($typeDef['elements'] as $element => $eData) {
                     $str .= $this->serializeTypeDef($element);
                 }
                 $str .= "</$type>";
             } elseif ($typeDef['typeClass'] == 'element') {
                 $str .= "></$type>";
             } else {
                 $str .= "/>";
             }
             return $str;
         }
         return false;
     }

◆ typeToForm()

nusoap_xmlschema::typeToForm	(	$name,
		$type
	)

returns HTML form elements that allow a user to enter values for creating an instance of the given type.

Parameters

string	$name	name for type instance
string	$type	name of type

Returns: string public

Deprecated:

Definition at line 1876 of file nusoap.php.

References nusoap_base\getLocalPart().

     {
         // get typedef
         if ($typeDef = $this->getTypeDef($type)) {
             // if struct
             if ($typeDef['phpType'] == 'struct') {
                 $buffer .= '<table>';
                 foreach ($typeDef['elements'] as $child => $childDef) {
                     $buffer .= "
                                         <tr><td align='right'>$childDef[name] (type: " . $this->getLocalPart($childDef['type']) . "):</td>
                                         <td><input type='text' name='parameters[" . $name . "][$childDef[name]]'></td></tr>";
                 }
                 $buffer .= '</table>';
                 // if array
             } elseif ($typeDef['phpType'] == 'array') {
                 $buffer .= '<table>';
                 for ($i = 0;$i < 3; $i++) {
                     $buffer .= "
                                         <tr><td align='right'>array item (type: $typeDef[arrayType]):</td>
                                         <td><input type='text' name='parameters[" . $name . "][]'></td></tr>";
                 }
                 $buffer .= '</table>';
                 // if scalar
             } else {
                 $buffer .= "<input type='text' name='parameters[$name]'>";
             }
         } else {
             $buffer .= "<input type='text' name='parameters[$name]'>";
         }
         return $buffer;
     }

Here is the call graph for this function:

◆ xdebug()

nusoap_xmlschema::xdebug ( $string )

adds debug data to the clas level debug string

Parameters

string $string debug data private

Definition at line 1711 of file nusoap.php.

References nusoap_base\debug().

     {
         $this->debug('<' . $this->schemaTargetNamespace . '> ' . $string);
     }

Here is the call graph for this function:

Field Documentation

◆ $attributes

nusoap_xmlschema::$attributes = array()

Definition at line 1096 of file nusoap.php.

◆ $complexTypes

nusoap_xmlschema::$complexTypes = array()

Definition at line 1097 of file nusoap.php.

◆ $complexTypeStack

nusoap_xmlschema::$complexTypeStack = array()

Definition at line 1098 of file nusoap.php.

◆ $currentComplexType

nusoap_xmlschema::$currentComplexType = null

Definition at line 1099 of file nusoap.php.

◆ $currentElement

nusoap_xmlschema::$currentElement = null

Definition at line 1102 of file nusoap.php.

◆ $currentSimpleType

nusoap_xmlschema::$currentSimpleType = null

Definition at line 1105 of file nusoap.php.

◆ $defaultNamespace

nusoap_xmlschema::$defaultNamespace = array()

Definition at line 1114 of file nusoap.php.

◆ $depth

nusoap_xmlschema::$depth = 0

Definition at line 1111 of file nusoap.php.

◆ $depth_array

nusoap_xmlschema::$depth_array = array()

Definition at line 1112 of file nusoap.php.

◆ $elements

nusoap_xmlschema::$elements = array()

Definition at line 1100 of file nusoap.php.

◆ $elementStack

nusoap_xmlschema::$elementStack = array()

Definition at line 1101 of file nusoap.php.

◆ $enclosingNamespaces

nusoap_xmlschema::$enclosingNamespaces

Definition at line 1091 of file nusoap.php.

◆ $imports

nusoap_xmlschema::$imports = array()

Definition at line 1107 of file nusoap.php.

◆ $message

nusoap_xmlschema::$message = array()

Definition at line 1113 of file nusoap.php.

◆ $parser

nusoap_xmlschema::$parser

Definition at line 1109 of file nusoap.php.

◆ $position

nusoap_xmlschema::$position = 0

Definition at line 1110 of file nusoap.php.

◆ $schema

nusoap_xmlschema::$schema = ''

Definition at line 1088 of file nusoap.php.

◆ $schemaInfo

nusoap_xmlschema::$schemaInfo = array()

Definition at line 1093 of file nusoap.php.

◆ $schemaTargetNamespace

nusoap_xmlschema::$schemaTargetNamespace = ''

Definition at line 1094 of file nusoap.php.

◆ $simpleTypes

nusoap_xmlschema::$simpleTypes = array()

Definition at line 1103 of file nusoap.php.

◆ $simpleTypeStack

nusoap_xmlschema::$simpleTypeStack = array()

Definition at line 1104 of file nusoap.php.

◆ $xml

nusoap_xmlschema::$xml = ''

Definition at line 1089 of file nusoap.php.

The documentation for this class was generated from the following file:

components/ILIAS/soap/lib/nusoap.php

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ addComplexType()

◆ addElement()

◆ addSimpleType()

◆ CreateTypeName()

◆ getPHPType()

◆ getTypeDef()

◆ parseFile()

◆ parseString()

◆ schemaCharacterData()

◆ schemaEndElement()

◆ schemaStartElement()

◆ serializeSchema()

◆ serializeTypeDef()

◆ typeToForm()

◆ xdebug()

Field Documentation

◆ $attributes

◆ $complexTypes

◆ $complexTypeStack

◆ $currentComplexType

◆ $currentElement

◆ $currentSimpleType

◆ $defaultNamespace

◆ $depth

◆ $depth_array

◆ $elements

◆ $elementStack

◆ $enclosingNamespaces

◆ $imports

◆ $message

◆ $parser

◆ $position

◆ $schema

◆ $schemaInfo

◆ $schemaTargetNamespace

◆ $simpleTypes

◆ $simpleTypeStack

◆ $xml