XMLUri.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:18k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Id: XMLUri.hpp,v 1.9 2003/05/16 06:01:53 knoaman Exp $
  58.  * $Log: XMLUri.hpp,v $
  59.  * Revision 1.9  2003/05/16 06:01:53  knoaman
  60.  * Partial implementation of the configurable memory manager.
  61.  *
  62.  * Revision 1.8  2003/05/15 19:07:46  knoaman
  63.  * Partial implementation of the configurable memory manager.
  64.  *
  65.  * Revision 1.7  2003/01/06 19:43:18  tng
  66.  * New feature StandardUriConformant to force strict standard uri conformance.
  67.  *
  68.  * Revision 1.6  2002/11/21 15:42:39  gareth
  69.  * Implemented copy constructor and operator =. Patch by Jennifer Schachter.
  70.  *
  71.  * Revision 1.5  2002/11/04 15:22:05  tng
  72.  * C++ Namespace Support.
  73.  *
  74.  * Revision 1.4  2002/09/23 18:41:00  tng
  75.  * DOM L3: Support baseURI.   Add fURIText to XMLUri.   Added by Gareth Reakes and Thomas Ford.
  76.  *
  77.  * Revision 1.3  2002/08/23 20:45:24  tng
  78.  * .Memory leak fix: XMLUri data not deleted if constructor failed.
  79.  *
  80.  * Revision 1.2  2002/02/20 18:17:02  tng
  81.  * [Bug 5977] Warnings on generating apiDocs.
  82.  *
  83.  * Revision 1.1.1.1  2002/02/01 22:22:17  peiyongz
  84.  * sane_include
  85.  *
  86.  * Revision 1.3  2001/08/29 19:03:03  peiyongz
  87.  * Bugzilla# 2816:on AIX 4.2, xlC 3 r ev.1, Compilation error on inline method
  88.  *
  89.  * Revision 1.2  2001/08/16 14:09:44  peiyongz
  90.  * Removed unused ctors and methods
  91.  *
  92.  * Revision 1.1  2001/08/10 16:23:41  peiyongz
  93.  * XMLUri: creation
  94.  *
  95.  *
  96.  */
  97. #if !defined(XMLURI_HPP)
  98. #define XMLURI_HPP
  99. #include <xercesc/util/XMemory.hpp>
  100. #include <xercesc/util/XMLString.hpp>
  101. XERCES_CPP_NAMESPACE_BEGIN
  102. /*
  103.  * This class is a direct port of Java's URI class, to distinguish
  104.  * itself from the XMLURL, we use the name XMLUri instead of
  105.  * XMLURI.
  106.  *
  107.  * TODO: how to relate XMLUri and XMLURL since URL is part of URI.
  108.  *
  109.  */
  110.  class XMLUTIL_EXPORT XMLUri : public XMemory
  111. {
  112. public:
  113.     // -----------------------------------------------------------------------
  114.     //  Constructors and Destructor
  115.     // -----------------------------------------------------------------------
  116.     /**
  117.      * Construct a new URI from a URI specification string.
  118.      *
  119.      * If the specification follows the "generic URI" syntax, (two slashes
  120.      * following the first colon), the specification will be parsed
  121.      * accordingly - setting the
  122.      *                           scheme,
  123.      *                           userinfo,
  124.      *                           host,
  125.      *                           port,
  126.      *                           path,
  127.      *                           querystring and
  128.      *                           fragment
  129.      * fields as necessary.
  130.      *
  131.      * If the specification does not follow the "generic URI" syntax,
  132.      * the specification is parsed into a
  133.      *                           scheme and
  134.      *                           scheme-specific part (stored as the path) only.
  135.      *
  136.      * @param uriSpec the URI specification string (cannot be null or empty)
  137.      *
  138.      * ctor# 2
  139.      *
  140.      */
  141.     XMLUri(const XMLCh* const    uriSpec,
  142.            MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  143.     /**
  144.      * Construct a new URI from a base URI and a URI specification string.
  145.      * The URI specification string may be a relative URI.
  146.      *
  147.      * @param baseURI the base URI (cannot be null if uriSpec is null or
  148.      *                empty)
  149.      * @param uriSpec the URI specification string (cannot be null or
  150.      *                empty if base is null)
  151.      *
  152.      * ctor# 7 relative ctor
  153.      *
  154.      */
  155.     XMLUri(const XMLUri* const  baseURI
  156.          , const XMLCh* const   uriSpec
  157.          , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  158.     /**
  159.      * Copy constructor
  160.      */
  161.     XMLUri(const XMLUri& toCopy);
  162.     XMLUri& operator=(const XMLUri& toAssign);
  163.     virtual ~XMLUri();
  164.     // -----------------------------------------------------------------------
  165.     //  Getter methods
  166.     // -----------------------------------------------------------------------
  167.     /**
  168.      * Get the URI as a string specification. See RFC 2396 Section 5.2.
  169.      *
  170.      * @return the URI string specification
  171.      */
  172.     const XMLCh* getUriText() const;
  173.     /**
  174.      * Get the scheme for this URI.
  175.      *
  176.      * @return the scheme for this URI
  177.      */
  178.      const XMLCh* getScheme() const;
  179.     /**
  180.      * Get the userinfo for this URI.
  181.      *
  182.      * @return the userinfo for this URI (null if not specified).
  183.      */
  184.      const XMLCh* getUserInfo() const;
  185.     /**
  186.      * Get the host for this URI.
  187.      *
  188.      * @return the host for this URI (null if not specified).
  189.      */
  190.      const XMLCh* getHost() const;
  191.     /**
  192.      * Get the port for this URI.
  193.      *
  194.      * @return the port for this URI (-1 if not specified).
  195.      */
  196.      int getPort() const;
  197.     /**
  198.      * Get the path for this URI. Note that the value returned is the path
  199.      * only and does not include the query string or fragment.
  200.      *
  201.      * @return the path for this URI.
  202.      */
  203.      const XMLCh* getPath() const;
  204.     /**
  205.      * Get the query string for this URI.
  206.      *
  207.      * @return the query string for this URI. Null is returned if there
  208.      *         was no "?" in the URI spec, empty string if there was a
  209.      *         "?" but no query string following it.
  210.      */
  211.      const XMLCh* getQueryString() const;
  212.     /**
  213.      * Get the fragment for this URI.
  214.      *
  215.      * @return the fragment for this URI. Null is returned if there
  216.      *         was no "#" in the URI spec, empty string if there was a
  217.      *         "#" but no fragment following it.
  218.      */
  219.      const XMLCh* getFragment() const;
  220.     // -----------------------------------------------------------------------
  221.     //  Setter methods
  222.     // -----------------------------------------------------------------------
  223.     /**
  224.      * Set the scheme for this URI. The scheme is converted to lowercase
  225.      * before it is set.
  226.      *
  227.      * @param newScheme the scheme for this URI (cannot be null)
  228.      *
  229.      */
  230.      void setScheme(const XMLCh* const newScheme);
  231.     /**
  232.      * Set the userinfo for this URI. If a non-null value is passed in and
  233.      * the host value is null, then an exception is thrown.
  234.      *
  235.      * @param newUserInfo the userinfo for this URI
  236.      *
  237.      */
  238.      void setUserInfo(const XMLCh* const newUserInfo);
  239.     /**
  240.      * Set the host for this URI. If null is passed in, the userinfo
  241.      * field is also set to null and the port is set to -1.
  242.      *
  243.      * @param newHost the host for this URI
  244.      *
  245.      */
  246.      void setHost(const XMLCh* const newHost);
  247.     /**
  248.      * Set the port for this URI. -1 is used to indicate that the port is
  249.      * not specified, otherwise valid port numbers are  between 0 and 65535.
  250.      * If a valid port number is passed in and the host field is null,
  251.      * an exception is thrown.
  252.      *
  253.      * @param newPort the port number for this URI
  254.      *
  255.      */
  256.      void setPort(int newPort);
  257.     /**
  258.      * Set the path for this URI.
  259.      *
  260.      * If the supplied path is null, then the
  261.      * query string and fragment are set to null as well.
  262.      *
  263.      * If the supplied path includes a query string and/or fragment,
  264.      * these fields will be parsed and set as well.
  265.      *
  266.      * Note:
  267.      *
  268.      * For URIs following the "generic URI" syntax, the path
  269.      * specified should start with a slash.
  270.      *
  271.      * For URIs that do not follow the generic URI syntax, this method
  272.      * sets the scheme-specific part.
  273.      *
  274.      * @param newPath the path for this URI (may be null)
  275.      *
  276.      */
  277.      void setPath(const XMLCh* const newPath);
  278.     /**
  279.      * Set the query string for this URI. A non-null value is valid only
  280.      * if this is an URI conforming to the generic URI syntax and
  281.      * the path value is not null.
  282.      *
  283.      * @param newQueryString the query string for this URI
  284.      *
  285.      */
  286.      void setQueryString(const XMLCh* const newQueryString);
  287.     /**
  288.      * Set the fragment for this URI. A non-null value is valid only
  289.      * if this is a URI conforming to the generic URI syntax and
  290.      * the path value is not null.
  291.      *
  292.      * @param newFragment the fragment for this URI
  293.      *
  294.      */
  295.      void setFragment(const XMLCh* const newFragment);
  296.      // -----------------------------------------------------------------------
  297.     //  Miscellaneous methods
  298.     // -----------------------------------------------------------------------
  299.     /**
  300.      * Determine whether a given string contains only URI characters (also
  301.      * called "uric" in RFC 2396). uric consist of all reserved
  302.      * characters, unreserved characters and escaped characters.
  303.      *
  304.      * @return true if the string is comprised of uric, false otherwise
  305.      */
  306.     static bool isURIString(const XMLCh* const uric);
  307. private:
  308.     static const XMLCh RESERVED_CHARACTERS[];
  309.     static const XMLCh MARK_CHARACTERS[];
  310.     static const XMLCh SCHEME_CHARACTERS[];
  311.     static const XMLCh USERINFO_CHARACTERS[];
  312.     //helper method for getUriText
  313.     void buildFullText();
  314.     // -----------------------------------------------------------------------
  315.     //  Private helper methods
  316.     // -----------------------------------------------------------------------
  317.     /**
  318.      * Determine whether a character is a reserved character:
  319.      *
  320.      * @return true if the string contains any reserved characters
  321.      */
  322.     static bool isReservedCharacter(const XMLCh theChar);
  323.     /**
  324.      * Determine whether a char is an unreserved character.
  325.      *
  326.      * @return true if the char is unreserved, false otherwise
  327.      */
  328.     static bool isUnreservedCharacter(const XMLCh theChar);
  329.     /**
  330.      * Determine whether a scheme conforms to the rules for a scheme name.
  331.      * A scheme is conformant if it starts with an alphanumeric, and
  332.      * contains only alphanumerics, '+','-' and '.'.
  333.      *
  334.      * @return true if the scheme is conformant, false otherwise
  335.      */
  336.     static bool isConformantSchemeName(const XMLCh* const scheme);
  337.     /**
  338.      * Determine whether a userInfo conforms to the rules for a userinfo.
  339.      *
  340.      * @return true if the scheme is conformant, false otherwise
  341.      */
  342.     static void isConformantUserInfo(const XMLCh* const userInfo);
  343.     /**
  344.      * Determine whether a string is syntactically capable of representing
  345.      * a valid IPv4 address or the domain name of a network host.
  346.      *
  347.      * A valid IPv4 address consists of four decimal digit groups
  348.      * separated by a '.'.
  349.      *
  350.      * A hostname consists of domain labels (each of which must begin and
  351.      * end with an alphanumeric but may contain '-') separated by a '.'.
  352.      * See RFC 2396 Section 3.2.2.
  353.      *
  354.      * @return true if the string is a syntactically valid IPv4 address
  355.      *              or hostname
  356.      */
  357.      static bool isWellFormedAddress(const XMLCh* const addr);
  358.     /**
  359.      * Get the indicator as to whether this URI uses the "generic URI"
  360.      * syntax.
  361.      *
  362.      * @return true if this URI uses the "generic URI" syntax, false
  363.      *         otherwise
  364.      */
  365.      bool isGenericURI();
  366.     // -----------------------------------------------------------------------
  367.     //  Miscellaneous methods
  368.     // -----------------------------------------------------------------------
  369.     /**
  370.      * Initialize all fields of this URI from another URI.
  371.      *
  372.      * @param toCopy the URI to copy (cannot be null)
  373.      */
  374.      void initialize(const XMLUri& toCopy);
  375.     /**
  376.      * Initializes this URI from a base URI and a URI specification string.
  377.      * See RFC 2396 Section 4 and Appendix B for specifications on parsing
  378.      * the URI and Section 5 for specifications on resolving relative URIs
  379.      * and relative paths.
  380.      *
  381.      * @param baseURI the base URI (may be null if uriSpec is an absolute
  382.      *               URI)
  383.      *
  384.      * @param uriSpec the URI spec string which may be an absolute or
  385.      *                  relative URI (can only be null/empty if base
  386.      *                  is not null)
  387.      *
  388.      */
  389.      void initialize(const XMLUri* const baseURI
  390.                    , const XMLCh*  const uriSpec);
  391.     /**
  392.      * Initialize the scheme for this URI from a URI string spec.
  393.      *
  394.      * @param uriSpec the URI specification (cannot be null)
  395.      *
  396.      */
  397.      void initializeScheme(const XMLCh* const uriSpec);
  398.     /**
  399.      * Initialize the authority (userinfo, host and port) for this
  400.      * URI from a URI string spec.
  401.      *
  402.      * @param uriSpec the URI specification (cannot be null)
  403.      *
  404.      */
  405.      void initializeAuthority(const XMLCh* const uriSpec);
  406.     /**
  407.      * Initialize the path for this URI from a URI string spec.
  408.      *
  409.      * @param uriSpec the URI specification (cannot be null)
  410.      *
  411.      */
  412.      void initializePath(const XMLCh* const uriSpec);
  413.      /**
  414.       * cleanup the data variables
  415.       *
  416.       */
  417.      void cleanUp();
  418.     // -----------------------------------------------------------------------
  419.     //  Data members
  420.     //
  421.     //  for all the data member, we own it,
  422.     //  responsible for the creation and/or deletion for
  423.     //  the memory allocated.
  424.     //
  425.     // -----------------------------------------------------------------------
  426.     XMLCh*          fScheme;
  427.     XMLCh*          fUserInfo;
  428.     XMLCh*          fHost;
  429.     int             fPort;
  430.     XMLCh*          fPath;
  431.     XMLCh*          fQueryString;
  432.     XMLCh*          fFragment;
  433.     XMLCh*          fURIText;
  434.     MemoryManager*  fMemoryManager;
  435. };
  436. // ---------------------------------------------------------------------------
  437. //  XMLUri: Getter methods
  438. // ---------------------------------------------------------------------------
  439. inline const XMLCh* XMLUri::getScheme() const
  440. {
  441.     return fScheme;
  442. }
  443. inline const XMLCh* XMLUri::getUserInfo() const
  444. {
  445. return fUserInfo;
  446. }
  447. inline const XMLCh* XMLUri::getHost() const
  448. {
  449. return fHost;
  450. }
  451. inline int XMLUri::getPort() const
  452. {
  453. return fPort;
  454. }
  455. inline const XMLCh* XMLUri::getPath() const
  456. {
  457. return fPath;
  458. }
  459. inline const XMLCh* XMLUri::getQueryString() const
  460. {
  461. return fQueryString;
  462. }
  463. inline const XMLCh* XMLUri::getFragment() const
  464. {
  465. return fFragment;
  466. }
  467. inline const XMLCh* XMLUri::getUriText() const
  468. {
  469.     //
  470.     //  Fault it in if not already. Since this is a const method and we
  471.     //  can't use mutable members due the compilers we have to support,
  472.     //  we have to cast off the constness.
  473.     //
  474.     if (!fURIText)
  475.         ((XMLUri*)this)->buildFullText();
  476.     return fURIText;
  477. }
  478. // ---------------------------------------------------------------------------
  479. //  XMLUri: Helper methods
  480. // ---------------------------------------------------------------------------
  481. inline bool XMLUri::isReservedCharacter(const XMLCh theChar)
  482. {
  483.     return (XMLString::indexOf(RESERVED_CHARACTERS, theChar) != -1);
  484. }
  485. inline bool XMLUri::isUnreservedCharacter(const XMLCh theChar)
  486. {
  487.     return (XMLString::isAlphaNum(theChar) ||
  488.             XMLString::indexOf(MARK_CHARACTERS, theChar) != -1);
  489. }
  490. XERCES_CPP_NAMESPACE_END
  491. #endif