src/main/decaf/net/URI.h

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.
 */

#ifndef _DECAF_NET_URI_H_
#define _DECAF_NET_URI_H_

#include <decaf/util/Config.h>
#include <decaf/lang/Comparable.h>
#include <decaf/lang/exceptions/IllegalArgumentException.h>
#include <decaf/net/URISyntaxException.h>
#include <decaf/net/MalformedURLException.h>
#include <decaf/net/URL.h>
#include <decaf/internal/net/URIType.h>
#include <string>

namespace decaf{
namespace net{

    class DECAF_API URI : public lang::Comparable<URI> {
    private:

        // The structure that holds the parsed URI data.
        decaf::internal::net::URIType uri;

        // The original string entered from URI( string ), empty if not set.
        mutable std::string uriString;

        static const std::string unreserved;
        static const std::string punct;
        static const std::string reserved;
        static const std::string someLegal;
        static const std::string allLegal;

    public:

        URI();

        URI( const URI& uri );

        URI( const std::string& uri );

        URI( const std::string& scheme, const std::string& ssp, const std::string& fragment );

        URI( const std::string& scheme, const std::string& userInfo,
             const std::string& host, int port,
             const std::string& path, const std::string& query,
             const std::string& fragment );

        URI( const std::string& scheme, const std::string& host,
             const std::string& path, const std::string& fragment );

        URI( const std::string& scheme, const std::string& authority,
             const std::string& path, const std::string& query,
             const std::string& fragment );

        virtual ~URI() {}

        virtual int compareTo( const URI& value ) const;

        virtual bool equals( const URI& value ) const;

        virtual bool operator==( const URI& value ) const;

        virtual bool operator<( const URI& value ) const;

        std::string getAuthority() const;

        std::string getFragment() const;

        std::string getHost() const;

        std::string getPath() const;

        int getPort() const;

        std::string getQuery() const;

        std::string getScheme() const;

        std::string getUserInfo() const;

        std::string getRawAuthority() const;

        std::string getRawFragment() const;

        std::string getRawPath() const;

        std::string getRawQuery() const;

        std::string getRawSchemeSpecificPart() const;

        std::string getSchemeSpecificPart() const;

        std::string getRawUserInfo() const;

        bool isAbsolute() const;

        bool isOpaque() const;

        URI normalize() const;

        URI parseServerAuthority() const;

        URI relativize( const URI& uri ) const;

        URI resolve( const std::string& str ) const;

        URI resolve( const URI& uri ) const;

        std::string toString() const;

        URL toURL() const;

    public:   // Static Methods

        static URI create( const std::string uri );

    private:

        void parseURI( const std::string& uri, bool forceServer );

        /*
         * Quote illegal chars for each component, but not the others
         *
         * @param component the component to be converted
         * @param legalset the legal character set allowed in the component strng
         * @return the converted string
         */
        std::string quoteComponent( const std::string& component,
                                    const std::string& legalset );

        /*
         * Encode Unicode chars that are not part of US-ASCII char set into the
         * escaped form
         *
         * i.e. The Euro currency symbol is encoded as "%E2%82%AC".
         *
         * @param src the string to be encoded
         * @return the converted string
         */
        std::string encodeOthers( const std::string& src ) const;

        std::string decode( const std::string& src ) const;

        bool equalsHexCaseInsensitive( const std::string& first,
                                       const std::string& second ) const;

        /*
         * Takes a string that may contain hex sequences like %F1 or %2b and
         * converts the hex values following the '%' to lowercase.
         *
         * @param s - String to convert the hex in.
         */
        std::string convertHexToLowerCase( const std::string& s ) const;

        /*
         * Normalize path, and return the resulting string.
         *
         * @param path - the path value to normalize.
         */
        std::string normalize( const std::string& path ) const;

        void setSchemeSpecificPart();

    };

}}

#endif /*_DECAF_NET_URI_H_*/