You are here

class nusoap_base in Salesforce Suite 5

Same name in this branch
  1. 5 includes/nusoap.php \nusoap_base
  2. 5 includes/nusoap.orig.php \nusoap_base
Same name and namespace in other branches
  1. 5.2 includes/nusoap.php \nusoap_base
  2. 5.2 includes/nusoap.orig.php \nusoap_base

nusoap_base

@author Dietrich Ayala <dietrich@ganx4.com> @access public

Hierarchy

Expanded class hierarchy of nusoap_base

File

includes/nusoap.orig.php, line 63

View source
class nusoap_base {

  /**
   * Identification for HTTP headers.
   *
   * @var string
   * @access private
   */
  var $title = 'NuSOAP';

  /**
   * Version for HTTP headers.
   *
   * @var string
   * @access private
   */
  var $version = '0.7.2';

  /**
   * CVS revision for HTTP headers.
   *
   * @var string
   * @access private
   */
  var $revision = '$Revision$';

  /**
   * Current error string (manipulated by getError/setError)
   *
   * @var string
   * @access private
   */
  var $error_str = '';

  /**
   * Current debug string (manipulated by debug/appendDebug/clearDebug/getDebug/getDebugAsXMLComment)
   *
   * @var string
   * @access private
   */
  var $debug_str = '';

  /**
   * toggles automatic encoding of special characters as entities
   * (should always be true, I think)
   *
   * @var boolean
   * @access private
   */
  var $charencoding = true;

  /**
   * the debug level for this instance
   *
   * @var	integer
   * @access private
   */
  var $debugLevel;

  /**
   * set schema version
   *
   * @var      string
   * @access   public
   */
  var $XMLSchemaVersion = 'http://www.w3.org/2001/XMLSchema';

  /**
   * charset encoding for outgoing messages
   *
   * @var      string
   * @access   public
   */
  var $soap_defencoding = 'ISO-8859-1';

  //var $soap_defencoding = 'UTF-8';

  /**
   * namespaces in an array of prefix => uri
   *
   * this is "seeded" by a set of constants, but it may be altered by code
   *
   * @var      array
   * @access   public
   */
  var $namespaces = [
    'SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/',
    'xsd' => 'http://www.w3.org/2001/XMLSchema',
    'xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
    'SOAP-ENC' => 'http://schemas.xmlsoap.org/soap/encoding/',
  ];

  /**
   * namespaces used in the current context, e.g. during serialization
   *
   * @var      array
   * @access   private
   */
  var $usedNamespaces = [];

  /**
   * XML Schema types in an array of uri => (array of xml type => php type)
   * is this legacy yet?
   * no, this is used by the xmlschema class to verify type => namespace mappings.
   * @var      array
   * @access   public
   */
  var $typemap = [
    'http://www.w3.org/2001/XMLSchema' => [
      'string' => 'string',
      'boolean' => 'boolean',
      'float' => 'double',
      'double' => 'double',
      'decimal' => 'double',
      'duration' => '',
      'dateTime' => 'string',
      'time' => 'string',
      'date' => 'string',
      'gYearMonth' => '',
      'gYear' => '',
      'gMonthDay' => '',
      'gDay' => '',
      'gMonth' => '',
      'hexBinary' => 'string',
      'base64Binary' => 'string',
      // abstract "any" types
      'anyType' => 'string',
      'anySimpleType' => 'string',
      // derived datatypes
      'normalizedString' => 'string',
      'token' => 'string',
      'language' => '',
      'NMTOKEN' => '',
      'NMTOKENS' => '',
      'Name' => '',
      'NCName' => '',
      'ID' => '',
      'IDREF' => '',
      'IDREFS' => '',
      'ENTITY' => '',
      'ENTITIES' => '',
      'integer' => 'integer',
      'nonPositiveInteger' => 'integer',
      'negativeInteger' => 'integer',
      'long' => 'integer',
      'int' => 'integer',
      'short' => 'integer',
      'byte' => 'integer',
      'nonNegativeInteger' => 'integer',
      'unsignedLong' => '',
      'unsignedInt' => '',
      'unsignedShort' => '',
      'unsignedByte' => '',
      'positiveInteger' => '',
    ],
    'http://www.w3.org/2000/10/XMLSchema' => [
      'i4' => '',
      'int' => 'integer',
      'boolean' => 'boolean',
      'string' => 'string',
      'double' => 'double',
      'float' => 'double',
      'dateTime' => 'string',
      'timeInstant' => 'string',
      'base64Binary' => 'string',
      'base64' => 'string',
      'ur-type' => 'array',
    ],
    'http://www.w3.org/1999/XMLSchema' => [
      'i4' => '',
      'int' => 'integer',
      'boolean' => 'boolean',
      'string' => 'string',
      'double' => 'double',
      'float' => 'double',
      'dateTime' => 'string',
      'timeInstant' => 'string',
      'base64Binary' => 'string',
      'base64' => 'string',
      'ur-type' => 'array',
    ],
    'http://soapinterop.org/xsd' => [
      'SOAPStruct' => 'struct',
    ],
    'http://schemas.xmlsoap.org/soap/encoding/' => [
      'base64' => 'string',
      'array' => 'array',
      'Array' => 'array',
    ],
    'http://xml.apache.org/xml-soap' => [
      'Map',
    ],
  ];

  /**
   * XML entities to convert
   *
   * @var      array
   * @access   public
   * @deprecated
   * @see	expandEntities
   */
  var $xmlEntities = [
    'quot' => '"',
    'amp' => '&',
    'lt' => '<',
    'gt' => '>',
    'apos' => "'",
  ];

  /**
   * constructor
   *
   * @access	public
   */
  function nusoap_base() {
    $this->debugLevel = $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel;
  }

  /**
   * gets the global debug level, which applies to future instances
   *
   * @return	integer	Debug level 0-9, where 0 turns off
   * @access	public
   */
  function getGlobalDebugLevel() {
    return $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel;
  }

  /**
   * sets the global debug level, which applies to future instances
   *
   * @param	int	$level	Debug level 0-9, where 0 turns off
   * @access	public
   */
  function setGlobalDebugLevel($level) {
    $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel = $level;
  }

  /**
   * gets the debug level for this instance
   *
   * @return	int	Debug level 0-9, where 0 turns off
   * @access	public
   */
  function getDebugLevel() {
    return $this->debugLevel;
  }

  /**
   * sets the debug level for this instance
   *
   * @param	int	$level	Debug level 0-9, where 0 turns off
   * @access	public
   */
  function setDebugLevel($level) {
    $this->debugLevel = $level;
  }

  /**
   * adds debug data to the instance debug string with formatting
   *
   * @param    string $string debug data
   * @access   private
   */
  function debug($string) {
    if ($this->debugLevel > 0) {
      $this
        ->appendDebug($this
        ->getmicrotime() . ' ' . get_class($this) . ": {$string}\n");
    }
  }

  /**
   * adds debug data to the instance debug string without formatting
   *
   * @param    string $string debug data
   * @access   public
   */
  function appendDebug($string) {
    if ($this->debugLevel > 0) {

      // it would be nice to use a memory stream here to use
      // memory more efficiently
      $this->debug_str .= $string;
    }
  }

  /**
   * clears the current debug data for this instance
   *
   * @access   public
   */
  function clearDebug() {

    // it would be nice to use a memory stream here to use
    // memory more efficiently
    $this->debug_str = '';
  }

  /**
   * gets the current debug data for this instance
   *
   * @return   debug data
   * @access   public
   */
  function &getDebug() {

    // it would be nice to use a memory stream here to use
    // memory more efficiently
    return $this->debug_str;
  }

  /**
   * gets the current debug data for this instance as an XML comment
   * this may change the contents of the debug data
   *
   * @return   debug data as an XML comment
   * @access   public
   */
  function &getDebugAsXMLComment() {

    // it would be nice to use a memory stream here to use
    // memory more efficiently
    while (strpos($this->debug_str, '--')) {
      $this->debug_str = str_replace('--', '- -', $this->debug_str);
    }
    return "<!--\n" . $this->debug_str . "\n-->";
  }

  /**
   * expands entities, e.g. changes '<' to '&lt;'.
   *
   * @param	string	$val	The string in which to expand entities.
   * @access	private
   */
  function expandEntities($val) {
    if ($this->charencoding) {
      $val = str_replace('&', '&amp;', $val);
      $val = str_replace("'", '&apos;', $val);
      $val = str_replace('"', '&quot;', $val);
      $val = str_replace('<', '&lt;', $val);
      $val = str_replace('>', '&gt;', $val);
    }
    return $val;
  }

  /**
   * returns error string if present
   *
   * @return   mixed error string or false
   * @access   public
   */
  function getError() {
    if ($this->error_str != '') {
      return $this->error_str;
    }
    return false;
  }

  /**
   * sets error string
   *
   * @return   boolean $string error string
   * @access   private
   */
  function setError($str) {
    $this->error_str = $str;
  }

  /**
   * detect if array is a simple array or a struct (associative array)
   *
   * @param	mixed	$val	The PHP array
   * @return	string	(arraySimple|arrayStruct)
   * @access	private
   */
  function isArraySimpleOrStruct($val) {
    $keyList = array_keys($val);
    foreach ($keyList as $keyListValue) {
      if (!is_int($keyListValue)) {
        return 'arrayStruct';
      }
    }
    return 'arraySimple';
  }

  /**
   * serializes PHP values in accordance w/ section 5. Type information is
   * not serialized if $use == 'literal'.
   *
   * @param	mixed	$val	The value to serialize
   * @param	string	$name	The name (local part) of the XML element
   * @param	string	$type	The XML schema type (local part) for the element
   * @param	string	$name_ns	The namespace for the name of the XML element
   * @param	string	$type_ns	The namespace for the type of the element
   * @param	array	$attributes	The attributes to serialize as name=>value pairs
   * @param	string	$use	The WSDL "use" (encoded|literal)
   * @return	string	The serialized element, possibly with child elements
   * @access	public
   */
  function serialize_val($val, $name = false, $type = false, $name_ns = false, $type_ns = false, $attributes = false, $use = 'encoded') {
    $this
      ->debug("in serialize_val: name={$name}, type={$type}, name_ns={$name_ns}, type_ns={$type_ns}, use={$use}");
    $this
      ->appendDebug('value=' . $this
      ->varDump($val));
    $this
      ->appendDebug('attributes=' . $this
      ->varDump($attributes));
    if (is_object($val) && get_class($val) == 'soapval') {
      return $val
        ->serialize($use);
    }

    // force valid name if necessary
    if (is_numeric($name)) {
      $name = '__numeric_' . $name;
    }
    elseif (!$name) {
      $name = 'noname';
    }

    // if name has ns, add ns prefix to name
    $xmlns = '';
    if ($name_ns) {
      $prefix = 'nu' . rand(1000, 9999);
      $name = $prefix . ':' . $name;
      $xmlns .= " xmlns:{$prefix}=\"{$name_ns}\"";
    }

    // if type is prefixed, create type prefix
    if ($type_ns != '' && $type_ns == $this->namespaces['xsd']) {

      // need to fix this. shouldn't default to xsd if no ns specified
      // w/o checking against typemap
      $type_prefix = 'xsd';
    }
    elseif ($type_ns) {
      $type_prefix = 'ns' . rand(1000, 9999);
      $xmlns .= " xmlns:{$type_prefix}=\"{$type_ns}\"";
    }

    // serialize attributes if present
    $atts = '';
    if ($attributes) {
      foreach ($attributes as $k => $v) {
        $atts .= " {$k}=\"" . $this
          ->expandEntities($v) . '"';
      }
    }

    // serialize null value
    if (is_null($val)) {
      if ($use == 'literal') {

        // TODO: depends on minOccurs
        return "<{$name}{$xmlns} {$atts}/>";
      }
      else {
        if (isset($type) && isset($type_prefix)) {
          $type_str = " xsi:type=\"{$type_prefix}:{$type}\"";
        }
        else {
          $type_str = '';
        }
        return "<{$name}{$xmlns}{$type_str} {$atts} xsi:nil=\"true\"/>";
      }
    }

    // serialize if an xsd built-in primitive type
    if ($type != '' && isset($this->typemap[$this->XMLSchemaVersion][$type])) {
      if (is_bool($val)) {
        if ($type == 'boolean') {
          $val = $val ? 'true' : 'false';
        }
        elseif (!$val) {
          $val = 0;
        }
      }
      else {
        if (is_string($val)) {
          $val = $this
            ->expandEntities($val);
        }
      }
      if ($use == 'literal') {
        return "<{$name}{$xmlns} {$atts}>{$val}</{$name}>";
      }
      else {
        return "<{$name}{$xmlns} {$atts} xsi:type=\"xsd:{$type}\">{$val}</{$name}>";
      }
    }

    // detect type and serialize
    $xml = '';
    switch (true) {
      case is_bool($val) || $type == 'boolean':
        if ($type == 'boolean') {
          $val = $val ? 'true' : 'false';
        }
        elseif (!$val) {
          $val = 0;
        }
        if ($use == 'literal') {
          $xml .= "<{$name}{$xmlns} {$atts}>{$val}</{$name}>";
        }
        else {
          $xml .= "<{$name}{$xmlns} xsi:type=\"xsd:boolean\"{$atts}>{$val}</{$name}>";
        }
        break;
      case is_int($val) || is_long($val) || $type == 'int':
        if ($use == 'literal') {
          $xml .= "<{$name}{$xmlns} {$atts}>{$val}</{$name}>";
        }
        else {
          $xml .= "<{$name}{$xmlns} xsi:type=\"xsd:int\"{$atts}>{$val}</{$name}>";
        }
        break;
      case is_float($val) || is_double($val) || $type == 'float':
        if ($use == 'literal') {
          $xml .= "<{$name}{$xmlns} {$atts}>{$val}</{$name}>";
        }
        else {
          $xml .= "<{$name}{$xmlns} xsi:type=\"xsd:float\"{$atts}>{$val}</{$name}>";
        }
        break;
      case is_string($val) || $type == 'string':
        $val = $this
          ->expandEntities($val);
        if ($use == 'literal') {
          $xml .= "<{$name}{$xmlns} {$atts}>{$val}</{$name}>";
        }
        else {
          $xml .= "<{$name}{$xmlns} xsi:type=\"xsd:string\"{$atts}>{$val}</{$name}>";
        }
        break;
      case is_object($val):
        if (!$name) {
          $name = get_class($val);
          $this
            ->debug("In serialize_val, used class name {$name} as element name");
        }
        else {
          $this
            ->debug("In serialize_val, do not override name {$name} for element name for class " . get_class($val));
        }
        foreach (get_object_vars($val) as $k => $v) {
          $pXml = isset($pXml) ? $pXml . $this
            ->serialize_val($v, $k, false, false, false, false, $use) : $this
            ->serialize_val($v, $k, false, false, false, false, $use);
        }
        $xml .= '<' . $name . '>' . $pXml . '</' . $name . '>';
        break;
        break;
      case is_array($val) || $type:

        // detect if struct or array
        $valueType = $this
          ->isArraySimpleOrStruct($val);
        if ($valueType == 'arraySimple' || ereg('^ArrayOf', $type)) {
          $i = 0;
          if (is_array($val) && count($val) > 0) {
            foreach ($val as $v) {
              if (is_object($v) && get_class($v) == 'soapval') {
                $tt_ns = $v->type_ns;
                $tt = $v->type;
              }
              elseif (is_array($v)) {
                $tt = $this
                  ->isArraySimpleOrStruct($v);
              }
              else {
                $tt = gettype($v);
              }
              $array_types[$tt] = 1;

              // TODO: for literal, the name should be $name
              $xml .= $this
                ->serialize_val($v, 'item', false, false, false, false, $use);
              ++$i;
            }
            if (count($array_types) > 1) {
              $array_typename = 'xsd:anyType';
            }
            elseif (isset($tt) && isset($this->typemap[$this->XMLSchemaVersion][$tt])) {
              if ($tt == 'integer') {
                $tt = 'int';
              }
              $array_typename = 'xsd:' . $tt;
            }
            elseif (isset($tt) && $tt == 'arraySimple') {
              $array_typename = 'SOAP-ENC:Array';
            }
            elseif (isset($tt) && $tt == 'arrayStruct') {
              $array_typename = 'unnamed_struct_use_soapval';
            }
            else {

              // if type is prefixed, create type prefix
              if ($tt_ns != '' && $tt_ns == $this->namespaces['xsd']) {
                $array_typename = 'xsd:' . $tt;
              }
              elseif ($tt_ns) {
                $tt_prefix = 'ns' . rand(1000, 9999);
                $array_typename = "{$tt_prefix}:{$tt}";
                $xmlns .= " xmlns:{$tt_prefix}=\"{$tt_ns}\"";
              }
              else {
                $array_typename = $tt;
              }
            }
            $array_type = $i;
            if ($use == 'literal') {
              $type_str = '';
            }
            else {
              if (isset($type) && isset($type_prefix)) {
                $type_str = " xsi:type=\"{$type_prefix}:{$type}\"";
              }
              else {
                $type_str = " xsi:type=\"SOAP-ENC:Array\" SOAP-ENC:arrayType=\"" . $array_typename . "[{$array_type}]\"";
              }
            }

            // empty array
          }
          else {
            if ($use == 'literal') {
              $type_str = '';
            }
            else {
              if (isset($type) && isset($type_prefix)) {
                $type_str = " xsi:type=\"{$type_prefix}:{$type}\"";
              }
              else {
                $type_str = " xsi:type=\"SOAP-ENC:Array\" SOAP-ENC:arrayType=\"xsd:anyType[0]\"";
              }
            }
          }

          // TODO: for array in literal, there is no wrapper here
          $xml = "<{$name}{$xmlns}{$type_str}{$atts}>" . $xml . "</{$name}>";
        }
        else {

          // got a struct
          if (isset($type) && isset($type_prefix)) {
            $type_str = " xsi:type=\"{$type_prefix}:{$type}\"";
          }
          else {
            $type_str = '';
          }
          if ($use == 'literal') {
            $xml .= "<{$name}{$xmlns} {$atts}>";
          }
          else {
            $xml .= "<{$name}{$xmlns}{$type_str}{$atts}>";
          }
          foreach ($val as $k => $v) {

            // Apache Map
            if ($type == 'Map' && $type_ns == 'http://xml.apache.org/xml-soap') {
              $xml .= '<item>';
              $xml .= $this
                ->serialize_val($k, 'key', false, false, false, false, $use);
              $xml .= $this
                ->serialize_val($v, 'value', false, false, false, false, $use);
              $xml .= '</item>';
            }
            else {
              $xml .= $this
                ->serialize_val($v, $k, false, false, false, false, $use);
            }
          }
          $xml .= "</{$name}>";
        }
        break;
      default:
        $xml .= 'not detected, got ' . gettype($val) . ' for ' . $val;
        break;
    }
    return $xml;
  }

  /**
   * serializes a message
   *
   * @param string $body the XML of the SOAP body
   * @param mixed $headers optional string of XML with SOAP header content, or array of soapval objects for SOAP headers
   * @param array $namespaces optional the namespaces used in generating the body and headers
   * @param string $style optional (rpc|document)
   * @param string $use optional (encoded|literal)
   * @param string $encodingStyle optional (usually 'http://schemas.xmlsoap.org/soap/encoding/' for encoded)
   * @return string the message
   * @access public
   */
  function serializeEnvelope($body, $headers = false, $namespaces = [], $style = 'rpc', $use = 'encoded', $encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/') {

    // TODO: add an option to automatically run utf8_encode on $body and $headers
    // if $this->soap_defencoding is UTF-8.  Not doing this automatically allows
    // one to send arbitrary UTF-8 characters, not just characters that map to ISO-8859-1
    $this
      ->debug("In serializeEnvelope length=" . strlen($body) . " body (max 1000 characters)=" . substr($body, 0, 1000) . " style={$style} use={$use} encodingStyle={$encodingStyle}");
    $this
      ->debug("headers:");
    $this
      ->appendDebug($this
      ->varDump($headers));
    $this
      ->debug("namespaces:");
    $this
      ->appendDebug($this
      ->varDump($namespaces));

    // serialize namespaces
    $ns_string = '';
    foreach (array_merge($this->namespaces, $namespaces) as $k => $v) {
      $ns_string .= " xmlns:{$k}=\"{$v}\"";
    }
    if ($encodingStyle) {
      $ns_string = " SOAP-ENV:encodingStyle=\"{$encodingStyle}\"{$ns_string}";
    }

    // serialize headers
    if ($headers) {
      if (is_array($headers)) {
        $xml = '';
        foreach ($headers as $header) {
          $xml .= $this
            ->serialize_val($header, false, false, false, false, false, $use);
        }
        $headers = $xml;
        $this
          ->debug("In serializeEnvelope, serialzied array of headers to {$headers}");
      }
      $headers = "<SOAP-ENV:Header>" . $headers . "</SOAP-ENV:Header>";
    }

    // serialize envelope
    return '<?xml version="1.0" encoding="' . $this->soap_defencoding . '"?' . ">" . '<SOAP-ENV:Envelope' . $ns_string . ">" . $headers . "<SOAP-ENV:Body>" . $body . "</SOAP-ENV:Body>" . "</SOAP-ENV:Envelope>";
  }

  /**
   * formats a string to be inserted into an HTML stream
   *
   * @param string $str The string to format
   * @return string The formatted string
   * @access public
   * @deprecated
   */
  function formatDump($str) {
    $str = htmlspecialchars($str);
    return nl2br($str);
  }

  /**
   * contracts (changes namespace to prefix) a qualified name
   *
   * @param    string $qname qname
   * @return	string contracted qname
   * @access   private
   */
  function contractQname($qname) {

    // get element namespace

    //$this->xdebug("Contract $qname");
    if (strrpos($qname, ':')) {

      // get unqualified name
      $name = substr($qname, strrpos($qname, ':') + 1);

      // get ns
      $ns = substr($qname, 0, strrpos($qname, ':'));
      $p = $this
        ->getPrefixFromNamespace($ns);
      if ($p) {
        return $p . ':' . $name;
      }
      return $qname;
    }
    else {
      return $qname;
    }
  }

  /**
   * expands (changes prefix to namespace) a qualified name
   *
   * @param    string $string qname
   * @return	string expanded qname
   * @access   private
   */
  function expandQname($qname) {

    // get element prefix
    if (strpos($qname, ':') && !ereg('^http://', $qname)) {

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

      // get ns prefix
      $prefix = substr($qname, 0, strpos($qname, ':'));
      if (isset($this->namespaces[$prefix])) {
        return $this->namespaces[$prefix] . ':' . $name;
      }
      else {
        return $qname;
      }
    }
    else {
      return $qname;
    }
  }

  /**
   * returns the local part of a prefixed string
   * returns the original string, if not prefixed
   *
   * @param string $str The prefixed string
   * @return string The local part
   * @access public
   */
  function getLocalPart($str) {
    if ($sstr = strrchr($str, ':')) {

      // get unqualified name
      return substr($sstr, 1);
    }
    else {
      return $str;
    }
  }

  /**
   * returns the prefix part of a prefixed string
   * returns false, if not prefixed
   *
   * @param string $str The prefixed string
   * @return mixed The prefix or false if there is no prefix
   * @access public
   */
  function getPrefix($str) {
    if ($pos = strrpos($str, ':')) {

      // get prefix
      return substr($str, 0, $pos);
    }
    return false;
  }

  /**
   * pass it a prefix, it returns a namespace
   *
   * @param string $prefix The prefix
   * @return mixed The namespace, false if no namespace has the specified prefix
   * @access public
   */
  function getNamespaceFromPrefix($prefix) {
    if (isset($this->namespaces[$prefix])) {
      return $this->namespaces[$prefix];
    }

    //$this->setError("No namespace registered for prefix '$prefix'");
    return false;
  }

  /**
   * returns the prefix for a given namespace (or prefix)
   * or false if no prefixes registered for the given namespace
   *
   * @param string $ns The namespace
   * @return mixed The prefix, false if the namespace has no prefixes
   * @access public
   */
  function getPrefixFromNamespace($ns) {
    foreach ($this->namespaces as $p => $n) {
      if ($ns == $n || $ns == $p) {
        $this->usedNamespaces[$p] = $n;
        return $p;
      }
    }
    return false;
  }

  /**
   * returns the time in ODBC canonical form with microseconds
   *
   * @return string The time in ODBC canonical form with microseconds
   * @access public
   */
  function getmicrotime() {
    if (function_exists('gettimeofday')) {
      $tod = gettimeofday();
      $sec = $tod['sec'];
      $usec = $tod['usec'];
    }
    else {
      $sec = time();
      $usec = 0;
    }
    return strftime('%Y-%m-%d %H:%M:%S', $sec) . '.' . sprintf('%06d', $usec);
  }

  /**
   * Returns a string with the output of var_dump
   *
   * @param mixed $data The variable to var_dump
   * @return string The output of var_dump
   * @access public
   */
  function varDump($data) {
    ob_start();
    var_dump($data);
    $ret_val = ob_get_contents();
    ob_end_clean();
    return $ret_val;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
nusoap_base::$charencoding property * toggles automatic encoding of special characters as entities * (should always be true, I think) * * * @access private
nusoap_base::$debugLevel property * the debug level for this instance * * * @access private
nusoap_base::$debug_str property Current debug string (manipulated by debug/appendDebug/clearDebug/getDebug/getDebugAsXMLComment) * * * @access private
nusoap_base::$error_str property Current error string (manipulated by getError/setError) * * * @access private
nusoap_base::$namespaces property * namespaces in an array of prefix => uri * * this is "seeded" by a set of constants, but it may be altered by code * * * @access public
nusoap_base::$revision property * CVS revision for HTTP headers. * * * @access private
nusoap_base::$soap_defencoding property * charset encoding for outgoing messages * * * @access public
nusoap_base::$title property * Identification for HTTP headers. * * * @access private
nusoap_base::$typemap property * XML Schema types in an array of uri => (array of xml type => php type) * is this legacy yet? * no, this is used by the xmlschema class to verify type => namespace mappings. * * @access public
nusoap_base::$usedNamespaces property * namespaces used in the current context, e.g. during serialization * * * @access private
nusoap_base::$version property * Version for HTTP headers. * * * @access private
nusoap_base::$xmlEntities Deprecated property * XML entities to convert * * * @access public *
nusoap_base::$XMLSchemaVersion property * set schema version * * * @access public
nusoap_base::appendDebug function * adds debug data to the instance debug string without formatting * *
nusoap_base::clearDebug function * clears the current debug data for this instance * * @access public
nusoap_base::contractQname function * contracts (changes namespace to prefix) a qualified name * *
nusoap_base::debug function * adds debug data to the instance debug string with formatting * *
nusoap_base::expandEntities function * expands entities, e.g. changes '<' to '&lt;'. * *
nusoap_base::expandQname function * expands (changes prefix to namespace) a qualified name * *
nusoap_base::formatDump function * formats a string to be inserted into an HTML stream * *
nusoap_base::getDebug function * gets the current debug data for this instance * *
nusoap_base::getDebugAsXMLComment function * gets the current debug data for this instance as an XML comment * this may change the contents of the debug data * *
nusoap_base::getDebugLevel function * gets the debug level for this instance * *
nusoap_base::getError function * returns error string if present * *
nusoap_base::getGlobalDebugLevel function * gets the global debug level, which applies to future instances * *
nusoap_base::getLocalPart function returns the local part of a prefixed string returns the original string, if not prefixed
nusoap_base::getmicrotime function returns the time in ODBC canonical form with microseconds
nusoap_base::getNamespaceFromPrefix function pass it a prefix, it returns a namespace
nusoap_base::getPrefix function returns the prefix part of a prefixed string returns false, if not prefixed
nusoap_base::getPrefixFromNamespace function returns the prefix for a given namespace (or prefix) or false if no prefixes registered for the given namespace
nusoap_base::isArraySimpleOrStruct function * detect if array is a simple array or a struct (associative array) * *
nusoap_base::nusoap_base function * constructor * * @access public
nusoap_base::serializeEnvelope function serializes a message
nusoap_base::serialize_val function * serializes PHP values in accordance w/ section 5. Type information is * not serialized if $use == 'literal'. * * @access public
nusoap_base::setDebugLevel function * sets the debug level for this instance * *
nusoap_base::setError function * sets error string * *
nusoap_base::setGlobalDebugLevel function * sets the global debug level, which applies to future instances * *
nusoap_base::varDump function * Returns a string with the output of var_dump * *