PHP XML_Util::raiseError方法代码示例

 /**
  * check, whether string is valid XML name
  *
  * <p>XML names are used for tagname, attribute names and various
  * other, lesser known entities.</p>
  * <p>An XML name may only consist of alphanumeric characters,
  * dashes, undescores and periods, and has to start with a letter
  * or an underscore.</p>
  *
  * <code>
  * require_once 'XML/Util.php';
  *
  * // verify tag name
  * $result = XML_Util::isValidName('invalidTag?');
  * if (is_a($result, 'PEAR_Error')) {
  *    print 'Invalid XML name: ' . $result->getMessage();
  * }
  * </code>
  *
  * @param string $string string that should be checked
  *
  * @return mixed true, if string is a valid XML name, PEAR error otherwise
  * @access public
  * @static
  * @todo support for other charsets
  * @todo PEAR CS - unable to avoid 85-char limit on second preg_match
  */
 function isValidName($string)
 {
     // check for invalid chars
     if (!preg_match('/^[[:alpha:]_]$/', $string[0])) {
         return XML_Util::raiseError('XML names may only start with letter ' . 'or underscore', XML_UTIL_ERROR_INVALID_START);
     }
     // check for invalid chars
     if (!preg_match('/^([[:alpha:]_]([[:alnum:]\\-\\.]*)?:)?[[:alpha:]_]([[:alnum:]\\_\\-\\.]+)?$/', $string)) {
         return XML_Util::raiseError('XML names may only contain alphanumeric ' . 'chars, period, hyphen, colon and underscores', XML_UTIL_ERROR_INVALID_CHARS);
     }
     // XML name is valid
     return true;
 }

 /**
  * check, whether string is valid XML name
  *
  * <p>XML names are used for tagname, attribute names and various
  * other, lesser known entities.</p>
  * <p>An XML name may only consist of alphanumeric characters,
  * dashes, undescores and periods, and has to start with a letter
  * or an underscore.
  * </p>
  *
  * <code>
  * require_once 'XML/Util.php';
  * 
  * // verify tag name
  * $result = XML_Util::isValidName("invalidTag?");
  * if (XML_Util::isError($result)) {
  *    print "Invalid XML name: " . $result->getMessage();
  * }
  * </code>
  *
  * @access  public
  * @static
  * @param   string  $string string that should be checked
  * @return  mixed   $valid  true, if string is a valid XML name, PEAR error otherwise
  * @todo    support for other charsets
  */
 function isValidName($string)
 {
     // check for invalid chars
     if (!preg_match("/^[[:alnum:]_\\-.]\$/", $string[0])) {
         return XML_Util::raiseError("XML names may only start with letter or underscore", XML_UTIL_ERROR_INVALID_START);
     }
     // check for invalid chars
     if (!preg_match("/^([a-zA-Z_]([a-zA-Z0-9_\\-\\.]*)?:)?[a-zA-Z_]([a-zA-Z0-9_\\-\\.]+)?\$/", $string)) {
         return XML_Util::raiseError("XML names may only contain alphanumeric chars, period, hyphen, colon and underscores", XML_UTIL_ERROR_INVALID_CHARS);
     }
     // XML name is valid
     return true;
 }

 /**
  * create a tag from an array
  * this method awaits an array in the following format
  * <pre>
  * array(
  *  "qname"        => $qname         // qualified name of the tag
  *  "namespace"    => $namespace     // namespace prefix (optional, if qname is specified or no namespace)
  *  "localpart"    => $localpart,    // local part of the tagname (optional, if qname is specified)
  *  "attributes"   => array(),       // array containing all attributes (optional)
  *  "content"      => $content,      // tag content (optional)
  *  "namespaceUri" => $namespaceUri  // namespaceUri for the given namespace (optional)
  *   )
  * </pre>
  *
  * <code>
  * require_once 'XML/Util.php';
  *
  * $tag = array(
  *           "qname"        => "foo:bar",
  *           "namespaceUri" => "http://foo.com",
  *           "attributes"   => array( "key" => "value", "argh" => "fruit&vegetable" ),
  *           "content"      => "I'm inside the tag",
  *            );
  * // creating a tag with qualified name and namespaceUri
  * $string = PEAR_PackageFile_Generator_v2_XML_Util::createTagFromArray($tag);
  * </code>
  *
  * @access   public
  * @static
  * @param    array   $tag               tag definition
  * @param    integer $replaceEntities   whether to replace XML special chars in content, embedd it in a CData section or none of both
  * @param    boolean $multiline         whether to create a multiline tag where each attribute gets written to a single line
  * @param    string  $indent            string used to indent attributes (_auto indents attributes so they start at the same column)
  * @param    string  $linebreak         string used for linebreaks
  * @return   string  $string            XML tag
  * @see      PEAR_PackageFile_Generator_v2_XML_Util::createTag()
  * @uses     XML_Util::attributesToString() to serialize the attributes of the tag
  * @uses     XML_Util::splitQualifiedName() to get local part and namespace of a qualified name
  */
 function createTagFromArray($tag, $replaceEntities = PEAR_PackageFile_Generator_v2_XML_Util_REPLACE_ENTITIES, $multiline = false, $indent = "_auto", $linebreak = "\n", $encoding = PEAR_PackageFile_Generator_v2_XML_Util_ENTITIES_XML)
 {
     if (isset($tag["content"]) && !is_scalar($tag["content"])) {
         return XML_Util::raiseError("Supplied non-scalar value as tag content", PEAR_PackageFile_Generator_v2_XML_Util_ERROR_NON_SCALAR_CONTENT);
     }
     if (!isset($tag['qname']) && !isset($tag['localPart'])) {
         return XML_Util::raiseError('You must either supply a qualified name (qname) or local tag name (localPart).', PEAR_PackageFile_Generator_v2_XML_Util_ERROR_NO_TAG_NAME);
     }
     // if no attributes hav been set, use empty attributes
     if (!isset($tag["attributes"]) || !is_array($tag["attributes"])) {
         $tag["attributes"] = array();
     }
     // qualified name is not given
     if (!isset($tag["qname"])) {
         // check for namespace
         if (isset($tag["namespace"]) && !empty($tag["namespace"])) {
             $tag["qname"] = $tag["namespace"] . ":" . $tag["localPart"];
         } else {
             $tag["qname"] = $tag["localPart"];
         }
         // namespace URI is set, but no namespace
     } elseif (isset($tag["namespaceUri"]) && !isset($tag["namespace"])) {
         $parts = XML_Util::splitQualifiedName($tag["qname"]);
         $tag["localPart"] = $parts["localPart"];
         if (isset($parts["namespace"])) {
             $tag["namespace"] = $parts["namespace"];
         }
     }
     if (isset($tag["namespaceUri"]) && !empty($tag["namespaceUri"])) {
         // is a namespace given
         if (isset($tag["namespace"]) && !empty($tag["namespace"])) {
             $tag["attributes"]["xmlns:" . $tag["namespace"]] = $tag["namespaceUri"];
         } else {
             // define this Uri as the default namespace
             $tag["attributes"]["xmlns"] = $tag["namespaceUri"];
         }
     }
     // check for multiline attributes
     if ($multiline === true) {
         if ($indent === "_auto") {
             $indent = str_repeat(" ", strlen($tag["qname"]) + 2);
         }
     }
     // create attribute list
     $attList = XML_Util::attributesToString($tag["attributes"], true, $multiline, $indent, $linebreak);
     if (!isset($tag["content"]) || (string) $tag["content"] == '') {
         $tag = sprintf("<%s%s />", $tag["qname"], $attList);
     } else {
         if ($replaceEntities == PEAR_PackageFile_Generator_v2_XML_Util_REPLACE_ENTITIES) {
             $tag["content"] = PEAR_PackageFile_Generator_v2_XML_Util::replaceEntities($tag["content"], $encoding);
         } elseif ($replaceEntities == PEAR_PackageFile_Generator_v2_XML_Util_CDATA_SECTION) {
             $tag["content"] = XML_Util::createCDataSection($tag["content"]);
         }
         $tag = sprintf("<%s%s>%s</%s>", $tag["qname"], $attList, $tag["content"], $tag["qname"]);
     }
     return $tag;
 }