XMLUri.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * $Id: XMLUri.hpp 557254 2007-07-18 13:28:54Z amassari $
 */

#if !defined(XERCESC_INCLUDE_GUARD_XMLURI_HPP)
#define XERCESC_INCLUDE_GUARD_XMLURI_HPP

#include <xercesc/util/XMemory.hpp>
#include <xercesc/util/XMLString.hpp>

#include <xercesc/internal/XSerializable.hpp>
#include <xercesc/framework/XMLBuffer.hpp>

XERCES_CPP_NAMESPACE_BEGIN

/*
 * This class is a direct port of Java's URI class, to distinguish
 * itself from the XMLURL, we use the name XMLUri instead of
 * XMLURI.
 *
 * TODO: how to relate XMLUri and XMLURL since URL is part of URI.
 *
 */

class XMLUTIL_EXPORT XMLUri : public XSerializable, public XMemory
{
public:

    // -----------------------------------------------------------------------
    //  Constructors and Destructor
    // -----------------------------------------------------------------------

    XMLUri(const XMLCh* const    uriSpec,
           MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    XMLUri(const XMLUri* const  baseURI
         , const XMLCh* const   uriSpec
         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    XMLUri(const XMLUri& toCopy);
    XMLUri& operator=(const XMLUri& toAssign);

    virtual ~XMLUri();

    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
    const XMLCh* getUriText() const;

     const XMLCh* getScheme() const;

     const XMLCh* getUserInfo() const;


     const XMLCh* getHost() const;

     int getPort() const;
     
     const XMLCh* getRegBasedAuthority() const;

     const XMLCh* getPath() const;

     const XMLCh* getQueryString() const;

     const XMLCh* getFragment() const;

    // -----------------------------------------------------------------------
    //  Setter methods
    // -----------------------------------------------------------------------

     void setScheme(const XMLCh* const newScheme);

     void setUserInfo(const XMLCh* const newUserInfo);

     void setHost(const XMLCh* const newHost);

     void setPort(int newPort);
     
     void setRegBasedAuthority(const XMLCh* const newRegAuth);

     void setPath(const XMLCh* const newPath);

     void setQueryString(const XMLCh* const newQueryString);

     void setFragment(const XMLCh* const newFragment);

     // -----------------------------------------------------------------------
    //  Miscellaneous methods
    // -----------------------------------------------------------------------

    static bool isURIString(const XMLCh* const uric);

    static bool isValidURI( const XMLUri* const baseURI
                          , const XMLCh* const uriStr
                          , bool bAllowSpaces=false);
    static bool isValidURI( bool haveBaseURI
                          , const XMLCh* const uriStr
                          , bool bAllowSpaces=false);


    static void normalizeURI(const XMLCh*     const systemURI,
                                   XMLBuffer&       normalizedURI);

    /***
     * Support for Serialization/De-serialization
     ***/
    DECL_XSERIALIZABLE(XMLUri)

    XMLUri(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

private:

    static const XMLCh MARK_OR_RESERVED_CHARACTERS[];
    static const XMLCh RESERVED_CHARACTERS[];
    static const XMLCh MARK_CHARACTERS[];
    static const XMLCh SCHEME_CHARACTERS[];
    static const XMLCh USERINFO_CHARACTERS[];
    static const XMLCh REG_NAME_CHARACTERS[];
    static const XMLCh PATH_CHARACTERS[];

    //helper method for getUriText
    void buildFullText();

    // -----------------------------------------------------------------------
    //  Private helper methods
    // -----------------------------------------------------------------------

    static bool isReservedCharacter(const XMLCh theChar);
    
    static bool isPathCharacter(const XMLCh theChar);

    static bool isUnreservedCharacter(const XMLCh theChar);

    static bool isReservedOrUnreservedCharacter(const XMLCh theChar);

    static bool isConformantSchemeName(const XMLCh* const scheme);

    static void isConformantUserInfo(const XMLCh* const userInfo
        , MemoryManager* const manager);
    
    static bool isValidServerBasedAuthority(const XMLCh* const host
                                           , const XMLSize_t hostLen
                                           , const int port
                                           , const XMLCh* const userinfo
                                           , const XMLSize_t userLen);
                                           
    static bool isValidServerBasedAuthority(const XMLCh* const host
                                           , const int port
                                           , const XMLCh* const userinfo
                                           , MemoryManager* const manager);
      
    static bool isValidRegistryBasedAuthority(const XMLCh* const authority
                                             , const XMLSize_t authLen);

    static bool isValidRegistryBasedAuthority(const XMLCh* const authority);

     static bool isWellFormedAddress(const XMLCh* const addr
         , MemoryManager* const manager);
     
     static bool isWellFormedIPv4Address(const XMLCh* const addr, const XMLSize_t length);
     
     static bool isWellFormedIPv6Reference(const XMLCh* const addr, const XMLSize_t length);
     
     static int scanHexSequence (const XMLCh* const addr, XMLSize_t index, XMLSize_t end, int& counter);

     bool isGenericURI();

    // -----------------------------------------------------------------------
    //  Miscellaneous methods
    // -----------------------------------------------------------------------

     void initialize(const XMLUri& toCopy);

     void initialize(const XMLUri* const baseURI
                   , const XMLCh*  const uriSpec);

     void initializeScheme(const XMLCh* const uriSpec);

     void initializeAuthority(const XMLCh* const uriSpec);

     void initializePath(const XMLCh* const uriSpec);

     void cleanUp();

    static bool isConformantSchemeName(const XMLCh* const scheme,
                                       const XMLSize_t schemeLen);
    static bool processScheme(const XMLCh* const uriStr, XMLSize_t& index);
    static bool processAuthority(const XMLCh* const uriStr, const XMLSize_t authLen);
    static bool isWellFormedAddress(const XMLCh* const addr, const XMLSize_t addrLen);
    static bool processPath(const XMLCh* const pathStr, const XMLSize_t pathStrLen,
                            const bool isSchemePresent, const bool bAllowSpaces=false);

    // -----------------------------------------------------------------------
    //  Data members
    //
    //  for all the data member, we own it,
    //  responsible for the creation and/or deletion for
    //  the memory allocated.
    //
    // -----------------------------------------------------------------------
    int             fPort;
    XMLCh*          fScheme;
    XMLCh*          fUserInfo;
    XMLCh*          fHost;
    XMLCh*          fRegAuth;
    XMLCh*          fPath;
    XMLCh*          fQueryString;
    XMLCh*          fFragment;
    XMLCh*          fURIText;
    MemoryManager*  fMemoryManager;
};

// ---------------------------------------------------------------------------
//  XMLUri: Getter methods
// ---------------------------------------------------------------------------
inline const XMLCh* XMLUri::getScheme() const
{
    return fScheme;
}

inline const XMLCh* XMLUri::getUserInfo() const
{
    return fUserInfo;
}

inline const XMLCh* XMLUri::getHost() const
{
    return fHost;
}

inline int XMLUri::getPort() const
{
    return fPort;
}

inline const XMLCh* XMLUri::getRegBasedAuthority() const
{
    return fRegAuth;
}

inline const XMLCh* XMLUri::getPath() const
{
    return fPath;
}

inline const XMLCh* XMLUri::getQueryString() const
{
    return fQueryString;
}

inline const XMLCh* XMLUri::getFragment() const
{
    return fFragment;
}

inline const XMLCh* XMLUri::getUriText() const
{
    //
    //  Fault it in if not already. Since this is a const method and we
    //  can't use mutable members due the compilers we have to support,
    //  we have to cast off the constness.
    //
    if (!fURIText)
        ((XMLUri*)this)->buildFullText();

    return fURIText;
}

// ---------------------------------------------------------------------------
//  XMLUri: Helper methods
// ---------------------------------------------------------------------------
inline bool XMLUri::isReservedOrUnreservedCharacter(const XMLCh theChar)
{
   return (XMLString::isAlphaNum(theChar) ||
           XMLString::indexOf(MARK_OR_RESERVED_CHARACTERS, theChar) != -1);
}

inline bool XMLUri::isReservedCharacter(const XMLCh theChar)
{
    return (XMLString::indexOf(RESERVED_CHARACTERS, theChar) != -1);
}

inline bool XMLUri::isPathCharacter(const XMLCh theChar)
{
    return (XMLString::indexOf(PATH_CHARACTERS, theChar) != -1);
}

inline bool XMLUri::isUnreservedCharacter(const XMLCh theChar)
{
    return (XMLString::isAlphaNum(theChar) ||
            XMLString::indexOf(MARK_CHARACTERS, theChar) != -1);
}

XERCES_CPP_NAMESPACE_END

#endif