percent.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 Authors
 *
 * 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.
 */
 
#ifndef A11_PERCENT_H_
#define A11_PERCENT_H_
 
#include <cstddef>
#include <string>
#include <string_view>
 
#include <absl/status/status.h>
#include <absl/status/statusor.h>
#include <absl/strings/ascii.h>
#include <absl/strings/str_cat.h>
 
namespace a11::percent {
 
inline int HexDigit(char one) {
  if (one >= '0' && one <= '9') {
    return one - '0';
  }
  if (one >= 'a' && one <= 'f') {
    return one - 'a' + 10;
  }
  if (one >= 'A' && one <= 'F') {
    return one - 'A' + 10;
  }
  return -1;
}
 
inline std::string Decode(std::string_view value, bool plus_is_space = false) {
  std::string decoded;
  decoded.reserve(value.size());
  for (size_t index = 0; index < value.size(); ++index) {
    const char one = value[index];
    if (plus_is_space && one == '+') {
      decoded.push_back(' ');
      continue;
    }
    if (one == '%' && index + 2 < value.size()) {
      const int high = HexDigit(value[index + 1]);
      const int low = HexDigit(value[index + 2]);
      if (high >= 0 && low >= 0) {
        decoded.push_back(static_cast<char>((high << 4) | low));
        index += 2;
        continue;
      }
    }
    decoded.push_back(one);
  }
  return decoded;
}
 
inline absl::StatusOr<std::string> DecodeStrict(std::string_view value,
                                                std::string_view what) {
  std::string decoded;
  decoded.reserve(value.size());
  for (size_t index = 0; index < value.size(); ++index) {
    if (value[index] != '%') {
      decoded.push_back(value[index]);
      continue;
    }
    if (index + 2 >= value.size()) {
      return absl::InvalidArgumentError(
          absl::StrCat("Truncated percent escape in ", what));
    }
    const int high = HexDigit(value[index + 1]);
    const int low = HexDigit(value[index + 2]);
    if (high < 0 || low < 0) {
      return absl::InvalidArgumentError(
          absl::StrCat("Invalid percent escape in ", what));
    }
    decoded.push_back(static_cast<char>((high << 4) | low));
    index += 2;
  }
  return decoded;
}
 
inline std::string Encode(std::string_view value) {
  static constexpr std::string_view kLowerHex = "0123456789abcdef";
  std::string out;
  out.reserve(value.size());
  for (const char ch : value) {
    const auto byte = static_cast<unsigned char>(ch);
    if (absl::ascii_isalnum(byte) || byte == '-' || byte == '.' ||
        byte == '_' || byte == '~') {
      out.push_back(ch);
      continue;
    }
    out.push_back('%');
    out.push_back(kLowerHex[byte >> 4U]);
    out.push_back(kLowerHex[byte & 0x0FU]);
  }
  return out;
}
 
}  // namespace a11::percent
 
#endif  // A11_PERCENT_H_