class XMLSchema in Salesforce Suite 5

Same name in this branch
5 includes/nusoap.php \XMLSchema
5 includes/nusoap.orig.php \XMLSchema
Same name and namespace in other branches
5.2 includes/nusoap.php \XMLSchema
5.2 includes/nusoap.orig.php \XMLSchema
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 <dietrich@ganx4.com> @access public
Hierarchy

class \XMLSchema extends \nusoap_base
Expanded class hierarchy of XMLSchema
File

includes/nusoap.orig.php, line 998
View source
class XMLSchema extends nusoap_base {

  // files
  var $schema = '';
  var $xml = '';

  // namespaces
  var $enclosingNamespaces;

  // schema info
  var $schemaInfo = [];
  var $schemaTargetNamespace = '';

  // types, elements, attributes defined by the schema
  var $attributes = [];
  var $complexTypes = [];
  var $complexTypeStack = [];
  var $currentComplexType = null;
  var $elements = [];
  var $elementStack = [];
  var $currentElement = null;
  var $simpleTypes = [];
  var $simpleTypeStack = [];
  var $currentSimpleType = null;

  // imports
  var $imports = [];

  // parser vars
  var $parser;
  var $position = 0;
  var $depth = 0;
  var $depth_array = [];
  var $message = [];
  var $defaultNamespace = [];

  /**
   * 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 = []) {
    parent::nusoap_base();
    $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' || $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'])) {
          $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']) && ereg(':Array$', $attrs['base'])) {
            $this
              ->xdebug('complexType is unusual array');
            $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';

          // 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']) && ereg(':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);

        // 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['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'];
          $this->elements[$attrs['name']] = $attrs;
          $this->elements[$attrs['name']]['typeClass'] = 'element';
          $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 {
          $this
            ->xdebug("processing untyped element " . $attrs['name']);
          $this->currentElement = $attrs['name'];
          $this->elements[$attrs['name']] = $attrs;
          $this->elements[$attrs['name']]['typeClass'] = 'element';
          $attrs['type'] = $this->schemaTargetNamespace . ':' . $attrs['name'] . '_ContainedType';
          $this->elements[$attrs['name']]['type'] = $attrs['type'];
          $ename = $attrs['name'];
        }
        if (isset($ename) && $this->currentComplexType) {
          $this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs;
        }
        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 {
          $this
            ->xdebug('processing unnamed simpleType for element ' . $this->currentElement);
          $this->currentSimpleType = $this->currentElement . '_ContainedType';

          //$this->currentElement = false;
          $this->simpleTypes[$this->currentSimpleType] = $attrs;
          $this->simpleTypes[$this->currentSimpleType]['phpType'] = 'scalar';
        }
        break;
      case 'union':

        // simpleType type list
        break;
      default:
    }
  }

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

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

  /**
   * 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']) . "\"";
            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}: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
   * @deprecated
   */
  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 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.
   *
   * @param string
   * @return mixed
   * @access public
   * @see addComplexType
   * @see addSimpleType
   * @see addElement
   */
  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) {
          $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 (ereg('_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;
  }

  /**
   * 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
   * @deprecated
   */
  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
   * @deprecated
   */
  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 .= "\n\t\t\t\t\t<tr><td align='right'>{$childDef['name']} (type: " . $this
            ->getLocalPart($childDef['type']) . "):</td>\n\t\t\t\t\t<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 .= "\n\t\t\t\t\t<tr><td align='right'>array item (type: {$typeDef['arrayType']}):</td>\n\t\t\t\t\t<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)
   * @access public
   * @see getTypeDef
   */
  function addComplexType($name, $typeClass = 'complexType', $phpType = 'array', $compositor = '', $restrictionBase = '', $elements = [], $attrs = [], $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
      ->appendDebug($this
      ->varDump($this->complexTypes[$name]));
  }

  /**
   * adds a simple type to the schema
   *
   * @param string $name
   * @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
   * @param string $typeClass (should always be simpleType)
   * @param string $phpType (should always be scalar)
   * @param array $enumeration array of values
   * @access public
   * @see xmlschema
   * @see getTypeDef
   */
  function addSimpleType($name, $restrictionBase = '', $typeClass = 'simpleType', $phpType = 'scalar', $enumeration = []) {
    $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]));
  }

  /**
   * adds an element to the schema
   *
   * @param array $attrs attributes that must include name and type
   * @see xmlschema
   * @access public
   */
  function addElement($attrs) {
    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']]));
  }

}
Members

Name	Type	Description
XMLSchema::$attributes	property
XMLSchema::$complexTypes	property
XMLSchema::$complexTypeStack	property
XMLSchema::$currentComplexType	property
XMLSchema::$currentElement	property
XMLSchema::$currentSimpleType	property
XMLSchema::$defaultNamespace	property
XMLSchema::$depth	property
XMLSchema::$depth_array	property
XMLSchema::$elements	property
XMLSchema::$elementStack	property
XMLSchema::$enclosingNamespaces	property
XMLSchema::$imports	property
XMLSchema::$message	property
XMLSchema::$parser	property
XMLSchema::$position	property
XMLSchema::$schema	property
XMLSchema::$schemaInfo	property
XMLSchema::$schemaTargetNamespace	property
XMLSchema::$simpleTypes	property
XMLSchema::$simpleTypeStack	property
XMLSchema::$xml	property
XMLSchema::addComplexType	function	* adds a complex type to the schema * * example: array * * addType( * 'ArrayOfstring', * 'complexType', * 'array', * '', * 'SOAP-ENC:Array', *…
XMLSchema::addElement	function	* adds an element to the schema * *
XMLSchema::addSimpleType	function	* adds a simple type to the schema * *
XMLSchema::getPHPType	function	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…
XMLSchema::getTypeDef	function	returns an associative array of information about a given type returns false if no type exists by the given name
XMLSchema::parseFile	function	parse an XML file
XMLSchema::parseString	function	* parse an XML string * *
XMLSchema::schemaCharacterData	function	* element content handler * *
XMLSchema::schemaEndElement	function	* end-element handler * *
XMLSchema::schemaStartElement	function	* start-element handler * *
XMLSchema::serializeSchema	function	* serialize the schema * * @access public
XMLSchema::serializeTypeDef	function	returns a sample serialization of a given type, or false if no type by the given name
XMLSchema::typeToForm	function	returns HTML form elements that allow a user to enter values for creating an instance of the given type.
XMLSchema::xdebug	function	* adds debug data to the clas level debug string * *
XMLSchema::XMLSchema	function	* constructor * *
You are here

class XMLSchema in Salesforce Suite 5

Hierarchy

File

Members

API Navigation
