Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XalanParsedURI.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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.
 */

#if !defined(XALANPARSEDURI_HEADER_GUARD_1357924680)
#define XALANPARSEDURI_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>




XALAN_CPP_NAMESPACE_BEGIN



class XALAN_PLATFORMSUPPORT_EXPORT XalanParsedURI
{
public:

    // Flags to say if a component is defined.  Note that each component may
    // be defined but empty, except for the path.
#if defined(XALAN_INLINE_INITIALIZATION)
    static const int d_scheme       = 1;
    static const int d_authority    = 2;
    static const int d_query        = 4;
    static const int d_fragment     = 8;
#else
    enum eComponent
    {
        d_scheme    = 1,
        d_authority = 2,
        d_query     = 4,
        d_fragment  = 8
    };
#endif

    XalanParsedURI(MemoryManagerType&      theManager) :
        m_scheme(theManager),
        m_authority(theManager),
        m_path(theManager),
        m_query(theManager),
        m_fragment(theManager),
        m_defined(0)
    {
    }

    XalanParsedURI(
        const XalanDOMChar*         uriString,
        XalanDOMString::size_type   uriStringLen,
        MemoryManagerType&          theManager) : 
        m_scheme(theManager),
        m_authority(theManager),
        m_path(theManager),
        m_query(theManager),
        m_fragment(theManager),
        m_defined(0)
    {
        parse(uriString, uriStringLen);
    }

    XalanParsedURI(
        const XalanDOMString        &uriString,
        MemoryManagerType&          theManager) :
        m_scheme(theManager),
        m_authority(theManager),
        m_path(theManager),
        m_query(theManager),
        m_fragment(theManager),
        m_defined(0)
    {
        parse(uriString.c_str(), uriString.length());
    }

    MemoryManagerType&
    getMemoryManager()
    {
        return m_scheme.getMemoryManager();
    }
     
    void parse(
        const XalanDOMChar*         uriString,
        XalanDOMString::size_type   uriStringLen);
     
    void parse(
        const XalanDOMString &uriString)
    {
        parse(uriString.c_str(), uriString.length());
    }

    XalanDOMString& make(XalanDOMString&        theResult) const;

    void resolve(const XalanParsedURI &base);

    void resolve(
        const XalanDOMChar *base,
        const XalanDOMString::size_type baseLen)
    {
        XalanParsedURI baseURI(base, baseLen,getMemoryManager());

        resolve(baseURI);
    }

    void resolve(
        const XalanDOMString &base)
    {
        resolve(base.c_str(), base.length());
    }

    static XalanDOMString& resolve(
        const XalanDOMChar          *relative,
        XalanDOMString::size_type   relativeLen,
        const XalanDOMChar          *base,
        XalanDOMString::size_type   baseLen,
        XalanDOMString&             theResult
    );


    static XalanDOMString& resolve(
        const XalanDOMString    &relative,
        const XalanDOMString    &base,
        XalanDOMString&         theResult
    )
    {
        return resolve(relative.c_str(), relative.length(), base.c_str(), base.length(), theResult);
    }

    const XalanDOMString& getScheme() const 
    { 
        return m_scheme; 
    }

    bool isSchemeDefined() const 
    { 
        return m_defined & d_scheme;
    }

    void setScheme(const XalanDOMChar *scheme) 
    { 
        m_scheme = scheme;
        m_defined |= d_scheme;
    }

    void setScheme(const XalanDOMString &scheme) 
    { 
        m_scheme = scheme;
        m_defined |= d_scheme;
    }

    const XalanDOMString& getAuthority() const 
    { 
        return m_authority; 
    }

    bool isAuthorityDefined() const 
    { 
        return m_defined & d_authority ? true : false; 
    }

    void setAuthority(const XalanDOMChar *authority) 
    { 
        m_authority = authority;
        m_defined |= d_authority;
    }

    void setAuthority(const XalanDOMString &authority) 
    { 
        m_authority = authority;
        m_defined |= d_authority;
    }

    const XalanDOMString& getPath() const 
    { 
        return m_path; 
    }

    void setPath(const XalanDOMChar *path) 
    { 
        m_path = path;
    }

    void setPath(const XalanDOMString &path) 
    { 
        m_path = path;
    }

    const XalanDOMString& getQuery() const 
    { 
        return m_query; 
    }

    bool isQueryDefined() const 
    { 
        return m_defined & d_query ? true : false;
    }

    void setQuery(const XalanDOMChar *query) 
    { 
        m_query = query;
        m_defined |= d_query;
    }

    void setQuery(const XalanDOMString &query) 
    { 
        m_query = query;
        m_defined |= d_query;
    }

    const XalanDOMString& getFragment() const 
    { 
        return m_fragment; 
    }

    bool isFragmentDefined() const 
    { 
        return m_defined & d_fragment ? true : false;
    }

    void setFragment(const XalanDOMChar *fragment) 
    { 
        m_fragment = fragment;
        m_defined |= d_fragment;
    }

    void setFragment(const XalanDOMString &fragment) 
    { 
        m_fragment = fragment;
        m_defined |= d_fragment;
    }

    unsigned int getDefined() const
    {
        return m_defined;
    }

    void setDefined(unsigned int defined)
    {
        m_defined = defined;
    }

private:
    // not implemented
    XalanParsedURI();
    XalanParsedURI(const XalanParsedURI&);

    XalanDOMString  m_scheme;
    XalanDOMString  m_authority;
    XalanDOMString  m_path;
    XalanDOMString  m_query;
    XalanDOMString  m_fragment;

    unsigned int    m_defined;
};

XALAN_CPP_NAMESPACE_END

#endif // XALANPARSEDURI_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.