folly::Uri Class Reference

#include <Uri.h>

Public Member Functions
	Uri (StringPiece str)
const std::string &	scheme () const
const std::string &	username () const
const std::string &	password () const
const std::string &	host () const
std::string	hostname () const
uint16_t	port () const
const std::string &	path () const
const std::string &	query () const
const std::string &	fragment () const
std::string	authority () const
template<class String >
String	toString () const
std::string	str () const
fbstring	fbstr () const
void	setPort (uint16_t port)
const std::vector< std::pair< std::string, std::string > > &	getQueryParams ()

Private Attributes
std::string	scheme_
std::string	username_
std::string	password_
std::string	host_
bool	hasAuthority_
uint16_t	port_
std::string	path_
std::string	query_
std::string	fragment_
std::vector< std::pair< std::string, std::string > >	queryParams_

Detailed Description

Class representing a URI.

Consider http://www.facebook.com/foo/bar?key=foo#anchor

The URI is broken down into its parts: scheme ("http"), authority (ie. host and port, in most cases: "www.facebook.com"), path ("/foo/bar"), query ("key=foo") and fragment ("anchor"). The scheme is lower-cased.

If this Uri represents a URL, note that, to prevent ambiguity, the component parts are NOT percent-decoded; you should do this yourself with uriUnescape() (for the authority and path) and uriUnescape(..., UriEscapeMode::QUERY) (for the query, but probably only after splitting at '&' to identify the individual parameters).

Definition at line 43 of file Uri.h.

Constructor & Destructor Documentation

folly::Uri::Uri ( StringPiece  str )

explicit

Parse a Uri from a string. Throws std::invalid_argument on parse error.

Definition at line 35 of file Uri.cpp.

References authority(), folly::Range< Iter >::begin(), folly::Range< Iter >::empty(), folly::Range< Iter >::end(), folly::gen::first, fragment_, hasAuthority_, host_, password_, path_, port(), port_, query_, regex, scheme_, folly::pushmi::operators::transform, UNLIKELY, and username_.

                        : hasAuthority_(false), port_(0) {
  static const boost::regex uriRegex(
      "([a-zA-Z][a-zA-Z0-9+.-]*):" // scheme:
      "([^?#]*)" // authority and path
      "(?:\\?([^#]*))?" // ?query
      "(?:#(.*))?"); // #fragment
  static const boost::regex authorityAndPathRegex("//([^/]*)(/.*)?");

  boost::cmatch match;
  if (UNLIKELY(!boost::regex_match(str.begin(), str.end(), match, uriRegex))) {
    throw std::invalid_argument(to<std::string>("invalid URI ", str));
  }

  scheme_ = submatch(match, 1);
  std::transform(scheme_.begin(), scheme_.end(), scheme_.begin(), ::tolower);

  StringPiece authorityAndPath(match[2].first, match[2].second);
  boost::cmatch authorityAndPathMatch;
  if (!boost::regex_match(
          authorityAndPath.begin(),
          authorityAndPath.end(),
          authorityAndPathMatch,
          authorityAndPathRegex)) {
    // Does not start with //, doesn't have authority
    hasAuthority_ = false;
    path_ = authorityAndPath.str();
  } else {
    static const boost::regex authorityRegex(
        "(?:([^@:]*)(?::([^@]*))?@)?" // username, password
        "(\\[[^\\]]*\\]|[^\\[:]*)" // host (IP-literal (e.g. '['+IPv6+']',
                                   // dotted-IPv4, or named host)
        "(?::(\\d*))?"); // port

    const auto authority = authorityAndPathMatch[1];
    boost::cmatch authorityMatch;
    if (!boost::regex_match(
            authority.first,
            authority.second,
            authorityMatch,
            authorityRegex)) {
      throw std::invalid_argument(to<std::string>(
          "invalid URI authority ",
          StringPiece(authority.first, authority.second)));
    }

    StringPiece port(authorityMatch[4].first, authorityMatch[4].second);
    if (!port.empty()) {
      port_ = to<uint16_t>(port);
    }

    hasAuthority_ = true;
    username_ = submatch(authorityMatch, 1);
    password_ = submatch(authorityMatch, 2);
    host_ = submatch(authorityMatch, 3);
    path_ = submatch(authorityAndPathMatch, 2);
  }

  query_ = submatch(match, 3);
  fragment_ = submatch(match, 4);
}

Member Function Documentation

std::string folly::Uri::authority

(

)

const

Definition at line 96 of file Uri.cpp.

References folly::empty(), host(), password(), port(), folly::size(), string, folly::toAppend(), and username().

Referenced by fragment(), TEST(), and Uri().

                               {
  std::string result;

  // Port is 5 characters max and we have up to 3 delimiters.
  result.reserve(host().size() + username().size() + password().size() + 8);

  if (!username().empty() || !password().empty()) {
    result.append(username());

    if (!password().empty()) {
      result.push_back(':');
      result.append(password());
    }

    result.push_back('@');
  }

  result.append(host());

  if (port() != 0) {
    result.push_back(':');
    toAppend(port(), &result);
  }

  return result;
}

fbstring folly::Uri::fbstr ( ) const

inline

Definition at line 97 of file Uri.h.

Referenced by TEST().

                         {
    return toString<fbstring>();
  }

const std::string& folly::Uri::fragment ( ) const

inline

Definition at line 85 of file Uri.h.

References authority(), fragment_, string, and toString().

Referenced by folly::uri_detail::as_tuple(), and TEST().

                                    {
    return fragment_;
  }

const std::vector< std::pair< std::string, std::string > > & folly::Uri::getQueryParams

(

)

Get query parameters as key-value pairs. e.g. for URI containing query string: key1=foo&key2=&key3&=bar&=bar= In returned list, there are 3 entries: "key1" => "foo" "key2" => "" "key3" => "" Parts "=bar" and "=bar=" are ignored, as they are not valid query parameters. "=bar" is missing parameter name, while "=bar=" has more than one equal signs, we don't know which one is the delimiter for key and value.

Note, this method is not thread safe, it might update internal state, but only the first call to this method update the state. After the first call is finished, subsequent calls to this method are thread safe.

Returns

query parameter key-value pairs in a vector, each element is a pair of which the first element is parameter name and the second one is parameter value

Definition at line 132 of file Uri.cpp.

References folly::gen::first, query_, queryParams_, regex, and string.

Referenced by BENCHMARK(), setPort(), and TEST().

                                                                    {
  if (!query_.empty() && queryParams_.empty()) {
    // Parse query string
    static const boost::regex queryParamRegex(
        "(^|&)" /*start of query or start of parameter "&"*/
        "([^=&]*)=?" /*parameter name and "=" if value is expected*/
        "([^=&]*)" /*parameter value*/
        "(?=(&|$))" /*forward reference, next should be end of query or
                      start of next parameter*/);
    const boost::cregex_iterator paramBeginItr(
        query_.data(), query_.data() + query_.size(), queryParamRegex);
    boost::cregex_iterator paramEndItr;
    for (auto itr = paramBeginItr; itr != paramEndItr; ++itr) {
      if (itr->length(2) == 0) {
        // key is empty, ignore it
        continue;
      }
      queryParams_.emplace_back(
          std::string((*itr)[2].first, (*itr)[2].second), // parameter name
          std::string((*itr)[3].first, (*itr)[3].second) // parameter value
      );
    }
  }
  return queryParams_;
}

const std::string& folly::Uri::host ( ) const

inline

Get host part of URI. If host is an IPv6 address, square brackets will be returned, for example: "[::1]".

Definition at line 63 of file Uri.h.

References host_, hostname(), and string.

Referenced by folly::uri_detail::as_tuple(), authority(), and TEST().

                                {
    return host_;
  }

std::string folly::Uri::hostname

(

)

const

Get host part of URI. If host is an IPv6 address, square brackets will not be returned, for exmaple "::1"; otherwise it returns the same thing as host().

hostname() is what one needs to call if passing the host to any other tool or API that connects to that host/port; e.g. getaddrinfo() only understands IPv6 host without square brackets

Definition at line 123 of file Uri.cpp.

References host_.

Referenced by host(), and TEST().

                              {
  if (host_.size() > 0 && host_[0] == '[') {
    // If it starts with '[', then it should end with ']', this is ensured by
    // regex
    return host_.substr(1, host_.size() - 2);
  }
  return host_;
}

const std::string& folly::Uri::password ( ) const

inline

Definition at line 56 of file Uri.h.

References password_.

Referenced by folly::uri_detail::as_tuple(), authority(), and TEST().

                                    {
    return password_;
  }

const std::string& folly::Uri::path ( ) const

inline

Definition at line 79 of file Uri.h.

References path_.

Referenced by folly::uri_detail::as_tuple(), and TEST().

                                {
    return path_;
  }

uint16_t folly::Uri::port ( ) const

inline

Definition at line 76 of file Uri.h.

References port_.

Referenced by folly::uri_detail::as_tuple(), authority(), setPort(), TEST(), and Uri().

                        {
    return port_;
  }

const std::string& folly::Uri::query ( ) const

inline

Definition at line 82 of file Uri.h.

References query_.

Referenced by folly::uri_detail::as_tuple(), and TEST().

                                 {
    return query_;
  }

const std::string& folly::Uri::scheme ( ) const

inline

Definition at line 50 of file Uri.h.

References scheme_.

Referenced by folly::uri_detail::as_tuple(), and TEST().

                                  {
    return scheme_;
  }

void folly::Uri::setPort ( uint16_t  port )

inline

Definition at line 101 of file Uri.h.

References getQueryParams(), hasAuthority_, port(), and port_.

                              {
    hasAuthority_ = true;
    port_ = port;
  }

std::string folly::Uri::str ( ) const

inline

Definition at line 94 of file Uri.h.

                        {
    return toString<std::string>();
  }

template<class String >

String folly::Uri::toString

(

)

const

Definition at line 56 of file Uri-inl.h.

References folly::toAppend().

Referenced by fragment().

                           {
  String str;
  if (hasAuthority_) {
    toAppend(scheme_, "://", &str);
    if (!password_.empty()) {
      toAppend(username_, ":", password_, "@", &str);
    } else if (!username_.empty()) {
      toAppend(username_, "@", &str);
    }
    toAppend(host_, &str);
    if (port_ != 0) {
      toAppend(":", port_, &str);
    }
  } else {
    toAppend(scheme_, ":", &str);
  }
  toAppend(path_, &str);
  if (!query_.empty()) {
    toAppend("?", query_, &str);
  }
  if (!fragment_.empty()) {
    toAppend("#", fragment_, &str);
  }
  return str;
}

const std::string& folly::Uri::username ( ) const

inline

Definition at line 53 of file Uri.h.

References username_.

Referenced by folly::uri_detail::as_tuple(), authority(), and TEST().

                                    {
    return username_;
  }

Member Data Documentation

std::string folly::Uri::fragment_

private

Definition at line 137 of file Uri.h.

Referenced by fragment(), and Uri().

bool folly::Uri::hasAuthority_

private

Definition at line 133 of file Uri.h.

Referenced by setPort(), and Uri().

std::string folly::Uri::host_

private

Definition at line 132 of file Uri.h.

Referenced by host(), hostname(), and Uri().

std::string folly::Uri::password_

private

Definition at line 131 of file Uri.h.

Referenced by password(), and Uri().

std::string folly::Uri::path_

private

Definition at line 135 of file Uri.h.

Referenced by path(), and Uri().

uint16_t folly::Uri::port_

private

Definition at line 134 of file Uri.h.

Referenced by port(), setPort(), and Uri().

std::string folly::Uri::query_

private

Definition at line 136 of file Uri.h.

Referenced by getQueryParams(), query(), and Uri().

std::vector<std::pair<std::string, std::string> > folly::Uri::queryParams_

private

Definition at line 138 of file Uri.h.

Referenced by getQueryParams().

std::string folly::Uri::scheme_

private

Definition at line 129 of file Uri.h.

Referenced by scheme(), and Uri().

std::string folly::Uri::username_

private

Definition at line 130 of file Uri.h.

Referenced by Uri(), and username().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/Uri.h
• proxygen/folly/folly/Uri-inl.h
• proxygen/folly/folly/Uri.cpp