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/internal/net/URIType.h>
#include <string>

namespace decaf {
namespace net {

    class URL;

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