class soap_parser in Salesforce Suite 5

Same name in this branch
5 includes/nusoap.php \soap_parser
5 includes/nusoap.orig.php \soap_parser
Same name and namespace in other branches
5.2 includes/nusoap.php \soap_parser
5.2 includes/nusoap.orig.php \soap_parser
soap_parser class parses SOAP XML messages into native PHP values
@author Dietrich Ayala <dietrich@ganx4.com> @access public
Hierarchy

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

includes/nusoap.php, line 5808
View source
class soap_parser extends nusoap_base {
  var $xml = '';
  var $xml_encoding = '';
  var $method = '';
  var $root_struct = '';
  var $root_struct_name = '';
  var $root_struct_namespace = '';
  var $root_header = '';
  var $document = '';

  // incoming SOAP body (text)
  // determines where in the message we are (envelope,header,body,method)
  var $status = '';
  var $position = 0;
  var $depth = 0;
  var $default_namespace = '';
  var $namespaces = [];
  var $message = [];
  var $parent = '';
  var $fault = false;
  var $fault_code = '';
  var $fault_str = '';
  var $fault_detail = '';
  var $depth_array = [];
  var $debug_flag = true;
  var $soapresponse = NULL;
  var $responseHeaders = '';

  // incoming SOAP headers (text)
  var $body_position = 0;

  // for multiref parsing:
  // array of id => pos
  var $ids = [];

  // array of id => hrefs => pos
  var $multirefs = [];

  // toggle for auto-decoding element content
  var $decode_utf8 = true;

  /**
   * constructor that actually does the parsing
   *
   * @param    string $xml SOAP message
   * @param    string $encoding character encoding scheme of message
   * @param    string $method method for which XML is parsed (unused?)
   * @param    string $decode_utf8 whether to decode UTF-8 to ISO-8859-1
   * @access   public
   */
  function soap_parser($xml, $encoding = 'UTF-8', $method = '', $decode_utf8 = true) {
    parent::nusoap_base();
    $this->xml = $xml;
    $this->xml_encoding = $encoding;
    $this->method = $method;
    $this->decode_utf8 = $decode_utf8;

    // Check whether content has been read.
    if (!empty($xml)) {

      // Check XML encoding
      $pos_xml = strpos($xml, '<?xml');
      if ($pos_xml !== FALSE) {
        $xml_decl = substr($xml, $pos_xml, strpos($xml, '?>', $pos_xml + 2) - $pos_xml + 1);
        if (preg_match("/encoding=[\"']([^\"']*)[\"']/", $xml_decl, $res)) {
          $xml_encoding = $res[1];
          if (strtoupper($xml_encoding) != $encoding) {
            $err = "Charset from HTTP Content-Type '" . $encoding . "' does not match encoding from XML declaration '" . $xml_encoding . "'";
            $this
              ->debug($err);
            if ($encoding != 'ISO-8859-1' || strtoupper($xml_encoding) != 'UTF-8') {
              $this
                ->setError($err);
              return;
            }

            // when HTTP says ISO-8859-1 (the default) and XML says UTF-8 (the typical), assume the other endpoint is just sloppy and proceed
          }
          else {
            $this
              ->debug('Charset from HTTP Content-Type matches encoding from XML declaration');
          }
        }
        else {
          $this
            ->debug('No encoding specified in XML declaration');
        }
      }
      else {
        $this
          ->debug('No XML declaration');
      }
      $this
        ->debug('Entering soap_parser(), length=' . strlen($xml) . ', encoding=' . $encoding);

      // Create an XML parser - why not xml_parser_create_ns?
      $this->parser = xml_parser_create($this->xml_encoding);

      // Set the options for parsing the XML data.

      //xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
      xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
      xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->xml_encoding);

      // Set the object for the parser.
      xml_set_object($this->parser, $this);

      // Set the element handlers for the parser.
      xml_set_element_handler($this->parser, 'start_element', 'end_element');
      xml_set_character_data_handler($this->parser, 'character_data');

      // Parse the XML file.
      if (!xml_parse($this->parser, $xml, true)) {

        // Display an error message.
        $err = sprintf('XML error parsing SOAP payload on line %d: %s', xml_get_current_line_number($this->parser), xml_error_string(xml_get_error_code($this->parser)));
        $this
          ->debug($err);
        $this
          ->debug("XML payload:\n" . $xml);
        $this
          ->setError($err);
      }
      else {
        $this
          ->debug('parsed successfully, found root struct: ' . $this->root_struct . ' of name ' . $this->root_struct_name);

        // get final value
        $this->soapresponse = $this->message[$this->root_struct]['result'];

        // get header value: no, because this is documented as XML string
        //				if($this->root_header != '' && isset($this->message[$this->root_header]['result'])){
        //					$this->responseHeaders = $this->message[$this->root_header]['result'];
        //				}
        // resolve hrefs/ids
        if (sizeof($this->multirefs) > 0) {
          foreach ($this->multirefs as $id => $hrefs) {
            $this
              ->debug('resolving multirefs for id: ' . $id);
            $idVal = $this
              ->buildVal($this->ids[$id]);
            if (is_array($idVal) && isset($idVal['!id'])) {
              unset($idVal['!id']);
            }
            foreach ($hrefs as $refPos => $ref) {
              $this
                ->debug('resolving href at pos ' . $refPos);
              $this->multirefs[$id][$refPos] = $idVal;
            }
          }
        }
      }
      xml_parser_free($this->parser);
    }
    else {
      $this
        ->debug('xml was empty, didn\'t parse!');
      $this
        ->setError('xml was empty, didn\'t parse!');
    }
  }

  /**
   * start-element handler
   *
   * @param    resource $parser XML parser object
   * @param    string $name element name
   * @param    array $attrs associative array of attributes
   * @access   private
   */
  function start_element($parser, $name, $attrs) {

    // position in a total number of elements, starting from 0
    // update class level pos
    $pos = $this->position++;

    // and set mine
    $this->message[$pos] = array(
      'pos' => $pos,
      'children' => '',
      'cdata' => '',
    );

    // depth = how many levels removed from root?
    // set mine as current global depth and increment global depth value
    $this->message[$pos]['depth'] = $this->depth++;

    // else add self as child to whoever the current parent is
    if ($pos != 0) {
      $this->message[$this->parent]['children'] .= '|' . $pos;
    }

    // set my parent
    $this->message[$pos]['parent'] = $this->parent;

    // set self as current parent
    $this->parent = $pos;

    // set self as current value for this depth
    $this->depth_array[$this->depth] = $pos;

    // get element prefix
    if (strpos($name, ':')) {

      // get ns prefix
      $prefix = substr($name, 0, strpos($name, ':'));

      // get unqualified name
      $name = substr(strstr($name, ':'), 1);
    }

    // set status
    if ($name == 'Envelope') {
      $this->status = 'envelope';
    }
    elseif ($name == 'Header') {
      $this->root_header = $pos;
      $this->status = 'header';
    }
    elseif ($name == 'Body') {
      $this->status = 'body';
      $this->body_position = $pos;

      // set method
    }
    elseif ($this->status == 'body' && $pos == $this->body_position + 1) {
      $this->status = 'method';
      $this->root_struct_name = $name;
      $this->root_struct = $pos;
      $this->message[$pos]['type'] = 'struct';
      $this
        ->debug("found root struct {$this->root_struct_name}, pos {$this->root_struct}");
    }

    // set my status
    $this->message[$pos]['status'] = $this->status;

    // set name
    $this->message[$pos]['name'] = htmlspecialchars($name);

    // set attrs
    $this->message[$pos]['attrs'] = $attrs;

    // loop through atts, logging ns and type declarations
    $attstr = '';
    foreach ($attrs as $key => $value) {
      $key_prefix = $this
        ->getPrefix($key);
      $key_localpart = $this
        ->getLocalPart($key);

      // if ns declarations, add to class level array of valid namespaces
      if ($key_prefix == 'xmlns') {
        if (ereg('^http://www.w3.org/[0-9]{4}/XMLSchema$', $value)) {
          $this->XMLSchemaVersion = $value;
          $this->namespaces['xsd'] = $this->XMLSchemaVersion;
          $this->namespaces['xsi'] = $this->XMLSchemaVersion . '-instance';
        }
        $this->namespaces[$key_localpart] = $value;

        // set method namespace
        if ($name == $this->root_struct_name) {
          $this->methodNamespace = $value;
        }

        // if it's a type declaration, set type
      }
      elseif ($key_localpart == 'type') {
        $value_prefix = $this
          ->getPrefix($value);
        $value_localpart = $this
          ->getLocalPart($value);
        $this->message[$pos]['type'] = $value_localpart;
        $this->message[$pos]['typePrefix'] = $value_prefix;
        if (isset($this->namespaces[$value_prefix])) {
          $this->message[$pos]['type_namespace'] = $this->namespaces[$value_prefix];
        }
        else {
          if (isset($attrs['xmlns:' . $value_prefix])) {
            $this->message[$pos]['type_namespace'] = $attrs['xmlns:' . $value_prefix];
          }
        }

        // should do something here with the namespace of specified type?
      }
      elseif ($key_localpart == 'arrayType') {
        $this->message[$pos]['type'] = 'array';

        /* do arrayType ereg here
        			[1]    arrayTypeValue    ::=    atype asize
        			[2]    atype    ::=    QName rank*
        			[3]    rank    ::=    '[' (',')* ']'
        			[4]    asize    ::=    '[' length~ ']'
        			[5]    length    ::=    nextDimension* Digit+
        			[6]    nextDimension    ::=    Digit+ ','
        			*/
        $expr = '([A-Za-z0-9_]+):([A-Za-z]+[A-Za-z0-9_]+)\\[([0-9]+),?([0-9]*)\\]';
        if (ereg($expr, $value, $regs)) {
          $this->message[$pos]['typePrefix'] = $regs[1];
          $this->message[$pos]['arrayTypePrefix'] = $regs[1];
          if (isset($this->namespaces[$regs[1]])) {
            $this->message[$pos]['arrayTypeNamespace'] = $this->namespaces[$regs[1]];
          }
          else {
            if (isset($attrs['xmlns:' . $regs[1]])) {
              $this->message[$pos]['arrayTypeNamespace'] = $attrs['xmlns:' . $regs[1]];
            }
          }
          $this->message[$pos]['arrayType'] = $regs[2];
          $this->message[$pos]['arraySize'] = $regs[3];
          $this->message[$pos]['arrayCols'] = $regs[4];
        }

        // specifies nil value (or not)
      }
      elseif ($key_localpart == 'nil') {
        $this->message[$pos]['nil'] = $value == 'true' || $value == '1';

        // some other attribute
      }
      elseif ($key != 'href' && $key != 'xmlns' && $key_localpart != 'encodingStyle' && $key_localpart != 'root') {
        $this->message[$pos]['xattrs']['!' . $key] = $value;
      }
      if ($key == 'xmlns') {
        $this->default_namespace = $value;
      }

      // log id
      if ($key == 'id') {
        $this->ids[$value] = $pos;
      }

      // root
      if ($key_localpart == 'root' && $value == 1) {
        $this->status = 'method';
        $this->root_struct_name = $name;
        $this->root_struct = $pos;
        $this
          ->debug("found root struct {$this->root_struct_name}, pos {$pos}");
      }

      // for doclit
      $attstr .= " {$key}=\"{$value}\"";
    }

    // get namespace - must be done after namespace atts are processed
    if (isset($prefix)) {
      $this->message[$pos]['namespace'] = $this->namespaces[$prefix];
      $this->default_namespace = $this->namespaces[$prefix];
    }
    else {
      $this->message[$pos]['namespace'] = $this->default_namespace;
    }
    if ($this->status == 'header') {
      if ($this->root_header != $pos) {
        $this->responseHeaders .= "<" . (isset($prefix) ? $prefix . ':' : '') . "{$name}{$attstr}>";
      }
    }
    elseif ($this->root_struct_name != '') {
      $this->document .= "<" . (isset($prefix) ? $prefix . ':' : '') . "{$name}{$attstr}>";
    }
  }

  /**
   * end-element handler
   *
   * @param    resource $parser XML parser object
   * @param    string $name element name
   * @access   private
   */
  function end_element($parser, $name) {

    // position of current element is equal to the last value left in depth_array for my depth
    $pos = $this->depth_array[$this->depth--];

    // get element prefix
    if (strpos($name, ':')) {

      // get ns prefix
      $prefix = substr($name, 0, strpos($name, ':'));

      // get unqualified name
      $name = substr(strstr($name, ':'), 1);
    }

    // build to native type
    if (isset($this->body_position) && $pos > $this->body_position) {

      // deal w/ multirefs
      if (isset($this->message[$pos]['attrs']['href'])) {

        // get id
        $id = substr($this->message[$pos]['attrs']['href'], 1);

        // add placeholder to href array
        $this->multirefs[$id][$pos] = 'placeholder';

        // add set a reference to it as the result value
        $this->message[$pos]['result'] =& $this->multirefs[$id][$pos];

        // build complexType values
      }
      elseif ($this->message[$pos]['children'] != '') {

        // if result has already been generated (struct/array)
        if (!isset($this->message[$pos]['result'])) {
          $attrs = $this->message[$pos]['attrs'];
          $type = isset($attrs['xsi:type']) ? $attrs['xsi:type'] : null;
          $foundSObject = strpos($type, 'sObject');

          // RCHOI: specifically looking for type sObject
          if ($foundSObject) {
            $recordArray = $this
              ->buildVal($pos);
            $sobj = new sObject($this
              ->buildVal($pos));
            $this->message[$pos]['result'] = $sobj;
          }
          else {
            $this->message[$pos]['result'] = $this
              ->buildVal($pos);
          }
        }

        // build complexType values of attributes and possibly simpleContent
      }
      elseif (isset($this->message[$pos]['xattrs'])) {
        if (isset($this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
          $this->message[$pos]['xattrs']['!'] = null;
        }
        elseif (isset($this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
          if (isset($this->message[$pos]['type'])) {
            $this->message[$pos]['xattrs']['!'] = $this
              ->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
          }
          else {
            $parent = $this->message[$pos]['parent'];
            if (isset($this->message[$parent]['type']) && $this->message[$parent]['type'] == 'array' && isset($this->message[$parent]['arrayType'])) {
              $this->message[$pos]['xattrs']['!'] = $this
                ->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
            }
            else {
              $this->message[$pos]['xattrs']['!'] = $this->message[$pos]['cdata'];
            }
          }
        }
        $this->message[$pos]['result'] = $this->message[$pos]['xattrs'];

        // set value of simpleType (or nil complexType)
      }
      else {

        //$this->debug('adding data for scalar value '.$this->message[$pos]['name'].' of value '.$this->message[$pos]['cdata']);
        if (isset($this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
          $this->message[$pos]['xattrs']['!'] = null;
        }
        elseif (isset($this->message[$pos]['type'])) {
          $this->message[$pos]['result'] = $this
            ->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
        }
        else {
          $parent = $this->message[$pos]['parent'];
          if (isset($this->message[$parent]['type']) && $this->message[$parent]['type'] == 'array' && isset($this->message[$parent]['arrayType'])) {
            $this->message[$pos]['result'] = $this
              ->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
          }
          else {
            $this->message[$pos]['result'] = $this->message[$pos]['cdata'];
          }
        }

        /* add value to parent's result, if parent is struct/array
        			$parent = $this->message[$pos]['parent'];
        			if($this->message[$parent]['type'] != 'map'){
        				if(strtolower($this->message[$parent]['type']) == 'array'){
        					$this->message[$parent]['result'][] = $this->message[$pos]['result'];
        				} else {
        					$this->message[$parent]['result'][$this->message[$pos]['name']] = $this->message[$pos]['result'];
        				}
        			}
        			*/
      }
    }

    // for doclit
    if ($this->status == 'header') {
      if ($this->root_header != $pos) {
        $this->responseHeaders .= "</" . (isset($prefix) ? $prefix . ':' : '') . "{$name}>";
      }
    }
    elseif ($pos >= $this->root_struct) {
      $this->document .= "</" . (isset($prefix) ? $prefix . ':' : '') . "{$name}>";
    }

    // switch status
    if ($pos == $this->root_struct) {
      $this->status = 'body';
      $this->root_struct_namespace = $this->message[$pos]['namespace'];
    }
    elseif ($name == 'Body') {
      $this->status = 'envelope';
    }
    elseif ($name == 'Header') {
      $this->status = 'envelope';
    }
    elseif ($name == 'Envelope') {

      //
    }

    // set parent back to my parent
    $this->parent = $this->message[$pos]['parent'];
  }

  /**
   * element content handler
   *
   * @param    resource $parser XML parser object
   * @param    string $data element content
   * @access   private
   */
  function character_data($parser, $data) {
    $pos = $this->depth_array[$this->depth];
    if ($this->xml_encoding == 'UTF-8') {

      // TODO: add an option to disable this for folks who want
      // raw UTF-8 that, e.g., might not map to iso-8859-1
      // TODO: this can also be handled with xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, "ISO-8859-1");
      if ($this->decode_utf8) {
        $data = utf8_decode($data);
      }
    }
    $this->message[$pos]['cdata'] .= $data;

    // for doclit
    if ($this->status == 'header') {
      $this->responseHeaders .= $data;
    }
    else {
      $this->document .= $data;
    }
  }

  /**
   * get the parsed message
   *
   * @return	mixed
   * @access   public
   */
  function get_response() {
    return $this->soapresponse;
  }

  /**
   * get the parsed headers
   *
   * @return	string XML or empty if no headers
   * @access   public
   */
  function getHeaders() {
    return $this->responseHeaders;
  }

  /**
   * decodes simple types into PHP variables
   *
   * @param    string $value value to decode
   * @param    string $type XML type to decode
   * @param    string $typens XML type namespace to decode
   * @return	mixed PHP value
   * @access   private
   */
  function decodeSimple($value, $type, $typens) {

    // TODO: use the namespace!
    if (!isset($type) || $type == 'string' || $type == 'long' || $type == 'unsignedLong') {
      return (string) $value;
    }
    if ($type == 'int' || $type == 'integer' || $type == 'short' || $type == 'byte') {
      return (int) $value;
    }
    if ($type == 'float' || $type == 'double' || $type == 'decimal') {
      return (double) $value;
    }
    if ($type == 'boolean') {
      if (strtolower($value) == 'false' || strtolower($value) == 'f') {
        return false;
      }
      return (bool) $value;
    }
    if ($type == 'base64' || $type == 'base64Binary') {
      $this
        ->debug('Decode base64 value');
      return base64_decode($value);
    }

    // obscure numeric types
    if ($type == 'nonPositiveInteger' || $type == 'negativeInteger' || $type == 'nonNegativeInteger' || $type == 'positiveInteger' || $type == 'unsignedInt' || $type == 'unsignedShort' || $type == 'unsignedByte') {
      return (int) $value;
    }

    // bogus: parser treats array with no elements as a simple type
    if ($type == 'array') {
      return array();
    }

    // everything else
    return (string) $value;
  }

  /**
   * builds response structures for compound values (arrays/structs)
   * and scalars
   *
   * @param    integer $pos position in node tree
   * @return	mixed	PHP value
   * @access   private
   */
  function buildVal($pos) {
    if (!isset($this->message[$pos]['type'])) {
      $this->message[$pos]['type'] = '';
    }
    $this
      ->debug('in buildVal() for ' . $this->message[$pos]['name'] . "(pos {$pos}) of type " . $this->message[$pos]['type']);

    // if there are children...
    if ($this->message[$pos]['children'] != '') {
      $this
        ->debug('in buildVal, there are children');
      $children = explode('|', $this->message[$pos]['children']);
      array_shift($children);

      // knock off empty
      // md array
      if (isset($this->message[$pos]['arrayCols']) && $this->message[$pos]['arrayCols'] != '') {
        $r = 0;

        // rowcount
        $c = 0;

        // colcount
        foreach ($children as $child_pos) {
          $this
            ->debug("in buildVal, got an MD array element: {$r}, {$c}");
          $params[$r][] = $this->message[$child_pos]['result'];
          $c++;
          if ($c == $this->message[$pos]['arrayCols']) {
            $c = 0;
            $r++;
          }
        }

        // array
      }
      elseif ($this->message[$pos]['type'] == 'array' || $this->message[$pos]['type'] == 'Array') {
        $this
          ->debug('in buildVal, adding array ' . $this->message[$pos]['name']);
        foreach ($children as $child_pos) {
          $params[] =& $this->message[$child_pos]['result'];
        }

        // apache Map type: java hashtable
      }
      elseif ($this->message[$pos]['type'] == 'Map' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
        $this
          ->debug('in buildVal, Java Map ' . $this->message[$pos]['name']);
        foreach ($children as $child_pos) {
          $kv = explode("|", $this->message[$child_pos]['children']);
          $params[$this->message[$kv[1]]['result']] =& $this->message[$kv[2]]['result'];
        }

        // generic compound type

        //} elseif($this->message[$pos]['type'] == 'SOAPStruct' || $this->message[$pos]['type'] == 'struct') {
      }
      else {

        // Apache Vector type: treat as an array
        $this
          ->debug('in buildVal, adding Java Vector ' . $this->message[$pos]['name']);
        if ($this->message[$pos]['type'] == 'Vector' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
          $notstruct = 1;
        }
        else {
          $notstruct = 0;
        }

        //
        foreach ($children as $child_pos) {
          if ($notstruct) {
            $params[] =& $this->message[$child_pos]['result'];
          }
          else {
            if (isset($params[$this->message[$child_pos]['name']])) {

              // de-serialize repeated element name into an array
              if (!is_array($params[$this->message[$child_pos]['name']]) || !isset($params[$this->message[$child_pos]['name']][0])) {
                $params[$this->message[$child_pos]['name']] = array(
                  $params[$this->message[$child_pos]['name']],
                );
              }
              $params[$this->message[$child_pos]['name']][] =& $this->message[$child_pos]['result'];
            }
            else {
              $params[$this->message[$child_pos]['name']] =& $this->message[$child_pos]['result'];
            }
          }
        }
      }
      if (isset($this->message[$pos]['xattrs'])) {
        $this
          ->debug('in buildVal, handling attributes');
        foreach ($this->message[$pos]['xattrs'] as $n => $v) {
          $params[$n] = $v;
        }
      }

      // handle simpleContent
      if (isset($this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
        $this
          ->debug('in buildVal, handling simpleContent');
        if (isset($this->message[$pos]['type'])) {
          $params['!'] = $this
            ->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
        }
        else {
          $parent = $this->message[$pos]['parent'];
          if (isset($this->message[$parent]['type']) && $this->message[$parent]['type'] == 'array' && isset($this->message[$parent]['arrayType'])) {
            $params['!'] = $this
              ->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
          }
          else {
            $params['!'] = $this->message[$pos]['cdata'];
          }
        }
      }
      return is_array($params) ? $params : array();
    }
    else {
      $this
        ->debug('in buildVal, no children, building scalar');
      $cdata = isset($this->message[$pos]['cdata']) ? $this->message[$pos]['cdata'] : '';
      if (isset($this->message[$pos]['type'])) {
        return $this
          ->decodeSimple($cdata, $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
      }
      $parent = $this->message[$pos]['parent'];
      if (isset($this->message[$parent]['type']) && $this->message[$parent]['type'] == 'array' && isset($this->message[$parent]['arrayType'])) {
        return $this
          ->decodeSimple($cdata, $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
      }
      return $this->message[$pos]['cdata'];
    }
  }

}
Members

Name	Type	Description
soap_parser::$body_position	property
soap_parser::$debug_flag	property
soap_parser::$decode_utf8	property
soap_parser::$default_namespace	property
soap_parser::$depth	property
soap_parser::$depth_array	property
soap_parser::$document	property
soap_parser::$fault	property
soap_parser::$fault_code	property
soap_parser::$fault_detail	property
soap_parser::$fault_str	property
soap_parser::$ids	property
soap_parser::$message	property
soap_parser::$method	property
soap_parser::$multirefs	property
soap_parser::$namespaces	property
soap_parser::$parent	property
soap_parser::$position	property
soap_parser::$responseHeaders	property
soap_parser::$root_header	property
soap_parser::$root_struct	property
soap_parser::$root_struct_name	property
soap_parser::$root_struct_namespace	property
soap_parser::$soapresponse	property
soap_parser::$status	property
soap_parser::$xml	property
soap_parser::$xml_encoding	property
soap_parser::buildVal	function	* builds response structures for compound values (arrays/structs) * and scalars * *
soap_parser::character_data	function	* element content handler * *
soap_parser::decodeSimple	function	* decodes simple types into PHP variables * *
soap_parser::end_element	function	* end-element handler * *
soap_parser::getHeaders	function	* get the parsed headers * *
soap_parser::get_response	function	* get the parsed message * *
soap_parser::soap_parser	function	* constructor that actually does the parsing * *
soap_parser::start_element	function	* start-element handler * *
You are here

class soap_parser in Salesforce Suite 5

Hierarchy

File

Members

API Navigation
