Location: PHPKode > projects > Taxonomic Search Engine > lib/class.xmlschema.php
<?php









/**

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

* no validation... yet.

* very experimental and limited. As is discussed on XML-DEV, I'm one of the people

* that just doesn't have time to read the spec(s) thoroughly, and just have a couple of trusty

* tutorials I refer to :)

*

* @author   Dietrich Ayala <hide@address.com>

* @version  $Id: class.xmlschema.php,v 1.1.1.1 2005/05/19 10:31:11 rdmpage Exp $

* @access   public

*/

class XMLSchema extends nusoap_base  {

	

	// files

	var $schema = '';

	var $xml = '';

	// namespaces

	var $enclosingNamespaces;

	// schema info

	var $schemaInfo = array();

	var $schemaTargetNamespace = '';

	// types, elements, attributes defined by the schema

	var $attributes = array();

	var $complexTypes = array();

	var $currentComplexType = false;

	var $elements = array();

	var $currentElement = false;

	var $simpleTypes = array();

	var $currentSimpleType = false;

	// imports

	var $imports = array();

	// parser vars

	var $parser;

	var $position = 0;

	var $depth = 0;

	var $depth_array = array();

	var $message = array();

	var $defaultNamespace = array();

    

	/**

	* constructor

	*

	* @param    string $schema schema document URI

	* @param    string $xml xml document URI

	* @param	string $namespaces namespaces defined in enclosing XML

	* @access   public

	*/

	function XMLSchema($schema='',$xml='',$namespaces=array()){



		$this->debug('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');

		}



	}



    /**

    * parse an XML file

    *

    * @param string $xml, path/URL to XML file

    * @param string $type, (schema | xml)

	* @return boolean

    * @access public

    */

	function parseFile($xml,$type){

		// 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;

	}



	/**

	* parse an XML string

	*

	* @param    string $xml path or URL

    * @param string $type, (schema|xml)

	* @access   private

	*/

	function parseString($xml,$type){

		// 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 object for the parser.

	    	xml_set_object($this->parser, $this);



	    	// Set the element handlers for the parser.

			if($type == "schema"){

		    	xml_set_element_handler($this->parser, 'schemaStartElement','schemaEndElement');

		    	xml_set_character_data_handler($this->parser,'schemaCharacterData');

			} elseif($type == "xml"){

				xml_set_element_handler($this->parser, 'xmlStartElement','xmlEndElement');

		    	xml_set_character_data_handler($this->parser,'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()!!');

		}

	}



	/**

	* start-element handler

	*

	* @param    string $parser XML parser object

	* @param    string $name element name

	* @param    string $attrs associative array of attributes

	* @access   private

	*/

	function schemaStartElement($parser, $name, $attrs) {

		

		// 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(ereg("^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'){

						$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':

			case 'choice':

			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':

            	//$this->xdebug("parsing attribute $attrs[name] $attrs[ref] of value: ".$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']);

            	$this->xdebug("parsing attribute " . $this->varDump($attrs));

            	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(isset($this->currentComplexType)){

					$this->complexTypes[$this->currentComplexType]['attrs'][$aname] = $attrs;

				} elseif(isset($this->currentElement)){

					$this->elements[$this->currentElement]['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 'complexType':

				if(isset($attrs['name'])){

					$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';

					if(isset($attrs['base']) && ereg(':Array$',$attrs['base'])){

						$this->complexTypes[$this->currentComplexType]['phpType'] = 'array';

					} else {

						$this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';

					}

				}else{

					$this->xdebug('processing unnamed complexType for element '.$this->currentElement);

					$this->currentComplexType = $this->currentElement . '_ContainedType';

					$this->currentElement = false;

					$this->complexTypes[$this->currentComplexType] = $attrs;

					$this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';

					if(isset($attrs['base']) && ereg(':Array$',$attrs['base'])){

						$this->complexTypes[$this->currentComplexType]['phpType'] = 'array';

					} else {

						$this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';

					}

				}

			break;

			case 'element':

				// elements defined as part of a complex type should

				// not really be added to $this->elements, but for some

				// reason, they are

				if(isset($attrs['type'])){

					$this->xdebug("processing typed element ".$attrs['name']." of type ".$attrs['type']);

					$this->currentElement = $attrs['name'];

					$this->elements[ $attrs['name'] ] = $attrs;

					$this->elements[ $attrs['name'] ]['typeClass'] = 'element';

					if (!isset($this->elements[ $attrs['name'] ]['form'])) {

						$this->elements[ $attrs['name'] ]['form'] = $this->schemaInfo['elementFormDefault'];

					}

					$ename = $attrs['name'];

				} elseif(isset($attrs['ref'])){

					$ename = $attrs['ref'];

				} else {

					$this->xdebug("processing untyped element ".$attrs['name']);

					$this->currentElement = $attrs['name'];

					$this->elements[ $attrs['name'] ] = $attrs;

					$this->elements[ $attrs['name'] ]['typeClass'] = 'element';

					$this->elements[ $attrs['name'] ]['type'] = $this->schemaTargetNamespace . ':' . $attrs['name'] . '_ContainedType';

					if (!isset($this->elements[ $attrs['name'] ]['form'])) {

						$this->elements[ $attrs['name'] ]['form'] = $this->schemaInfo['elementFormDefault'];

					}

				}

				if(isset($ename) && $this->currentComplexType){

					$this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs;

				}

			break;

			// we ignore enumeration values

			//case 'enumeration':

			//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 'restriction':

				//$this->xdebug("in restriction for currentComplexType: $this->currentComplexType and currentElement: $this->currentElement");

				if($this->currentElement){

					$this->elements[$this->currentElement]['type'] = $attrs['base'];

				} elseif($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';

				}

			break;

			case 'simpleType':

				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 {

					//echo 'not parsing: '.$name;

					//var_dump($attrs);

				}

			break;

			default:

				//$this->xdebug("do not have anything to do for element $name");

		}

	}



	/**

	* end-element handler

	*

	* @param    string $parser XML parser object

	* @param    string $name element name

	* @access   private

	*/

	function schemaEndElement($parser, $name) {

		// 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];

        }

		// move on...

		if($name == 'complexType'){

			$this->currentComplexType = false;

			$this->currentElement = false;

		}

		if($name == 'element'){

			$this->currentElement = false;

		}

		if($name == 'simpleType'){

			$this->currentSimpleType = false;

		}

	}



	/**

	* element content handler

	*

	* @param    string $parser XML parser object

	* @param    string $data element content

	* @access   private

	*/

	function schemaCharacterData($parser, $data){

		$pos = $this->depth_array[$this->depth - 1];

		$this->message[$pos]['cdata'] .= $data;

	}



	/**

	* serialize the schema

	*

	* @access   public

	*/

	function serializeSchema(){



		$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']) . "\"/>\n";

					}

				}

			}

			// attributes

			if(isset($attrs['attrs']) && (count($attrs['attrs']) >= 1)){

				foreach($attrs['attrs'] as $attr => $aParts){

					$contentStr .= "    <$schemaPrefix:attribute ref=\"".$this->contractQName($aParts['ref']).'"';

					if(isset($aParts['http://schemas.xmlsoap.org/wsdl/:arrayType'])){

						$this->usedNamespaces['wsdl'] = $this->namespaces['wsdl'];

						$contentStr .= ' wsdl:arrayType="'.$this->contractQName($aParts['http://schemas.xmlsoap.org/wsdl/:arrayType']).'"';

					}

					$contentStr .= "/>\n";

				}

			}

			// if restriction

			if( isset($attrs['restrictionBase']) && $attrs['restrictionBase'] != ''){

				$contentStr = "   <$schemaPrefix:restriction base=\"".$this->contractQName($attrs['restrictionBase'])."\">\n".$contentStr."   </$schemaPrefix:restriction>\n";

			}

			// compositor obviates complex/simple content

			if(isset($attrs['compositor']) && ($attrs['compositor'] != '')){

				$contentStr = "  <$schemaPrefix:$attrs[compositor]>\n".$contentStr."  </$schemaPrefix:$attrs[compositor]>\n";

			}

			// complex or simple content

			elseif((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 => $attr){

				$xml .= " <$schemaPrefix:simpleType name=\"$typeName\">\n  <restriction base=\"".$this->contractQName($eParts['type'])."\"/>\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

		$el = "<$schemaPrefix:schema targetNamespace=\"$this->schemaTargetNamespace\"\n";

		foreach (array_diff($this->usedNamespaces, $this->enclosingNamespaces) as $nsp => $ns) {

			$el .= " xmlns:$nsp=\"$ns\"\n";

		}

		$xml = $el . ">\n".$xml."</$schemaPrefix:schema>\n";

		return $xml;

	}



	/**

	* adds debug data to the clas level debug string

	*

	* @param    string $string debug data

	* @access   private

	*/

	function xdebug($string){

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

	}



    /**

    * 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'

    *

    * @param string $type, name of defined type

    * @param string $ns, namespace of type

    * @return mixed

    * @access public

    */

	function getPHPType($type,$ns){

		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;

	}



	/**

    * returns an array of information about a given type

    * returns false if no type exists by the given name

    *

	*	 typeDef = array(

	*	 'elements' => array(), // refs to elements array

	*	'restrictionBase' => '',

	*	'phpType' => '',

	*	'order' => '(sequence|all)',

	*	'attrs' => array() // refs to attributes array

	*	)

    *

    * @param string

    * @return mixed

    * @access public

    */

	function getTypeDef($type){

		//$this->debug("in getTypeDef for type $type");

		if(isset($this->complexTypes[$type])){

			$this->xdebug("in getTypeDef, found complexType $type");

			return $this->complexTypes[$type];

		} elseif(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) {

					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) {

					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->elements[$type]['phpType'] = 'scalar';

				}

			}

			return $this->elements[$type];

		} elseif(isset($this->attributes[$type])){

			$this->xdebug("in getTypeDef, found attribute $type");

			return $this->attributes[$type];

		}

		$this->xdebug("in getTypeDef, did not find $type");

		return false;

	}



	/**

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

    *

    * @param string $type, name of type

    * @return mixed

    * @access public

    */

    function serializeTypeDef($type){

    	//print "in sTD() for type $type<br>";

	if($typeDef = $this->getTypeDef($type)){

		$str .= '<'.$type;

	    if(is_array($typeDef['attrs'])){

		foreach($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;

    }



    /**

    * returns HTML form elements that allow a user

    * to enter values for creating an instance of the given type.

    *

    * @param string $name, name for type instance

    * @param string $type, name of type

    * @return string

    * @access public

	*/

	function typeToForm($name,$type){

		// 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;

	}

	

	/**

	* 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')

	* );

	* 

	* @param name

	* @param typeClass (complexType|simpleType|attribute)

	* @param phpType: currently supported are array and struct (php assoc array)

	* @param compositor (all|sequence|choice)

	* @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)

	* @param elements = array ( name = array(name=>'',type=>'') )

	* @param attrs = array(

	* 	array(

	*		'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType",

	*		"http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]"

	* 	)

	* )

	* @param arrayType: namespace:name (http://www.w3.org/2001/XMLSchema:string)

	*

	*/

	function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType=''){

		$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->varDump($this->complexTypes[$name]));

	}

	

	/**

	* adds a simple type to the schema

	*

	* @param name

	* @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)

	* @param typeClass (simpleType)

	* @param phpType: (scalar)

	* @see xmlschema

	* 

	*/

	function addSimpleType($name, $restrictionBase='', $typeClass='simpleType', $phpType='scalar') {

		$this->simpleTypes[$name] = array(

	    'name'		=> $name,

	    'typeClass'	=> $typeClass,

	    'phpType'	=> $phpType,

	    'type' => $restrictionBase

		);

		

		$this->xdebug("addSimpleType $name: " . $this->varDump($this->simpleTypes[$name]));

	}

}









?>
Return current item: Taxonomic Search Engine