strings.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
 
namespace Azure { namespace Core { namespace _internal {
 
  struct StringExtensions final
  {
    static constexpr char ToUpper(char c) noexcept
    {
      return (c < 'a' || c > 'z') ? c : c - ('a' - 'A');
    }
 
    static constexpr char ToLower(char c) noexcept
    {
      return (c < 'A' || c > 'Z') ? c : c + ('a' - 'A');
    }
 
    static constexpr bool IsDigit(char c) noexcept { return c >= '0' && c <= '9'; }
 
    static constexpr bool IsHexDigit(char c) noexcept
    {
      return IsDigit(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
    }
 
    static constexpr bool IsAlpha(char c) noexcept
    {
      return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
    }
 
    static constexpr bool IsAlphaNumeric(char c) noexcept { return IsDigit(c) || IsAlpha(c); }
 
    static constexpr bool IsSpace(char c) noexcept { return c == ' ' || (c >= '\t' && c <= '\r'); }
 
    static constexpr bool IsPrintable(char c) noexcept { return c >= ' ' && c <= '~'; }
 
    struct CaseInsensitiveComparator final
    {
      bool operator()(std::string const& lhs, std::string const& rhs) const
      {
        return std::lexicographical_compare(
            lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](auto l, auto r) {
              return ToLower(l) < ToLower(r);
            });
      }
    };
 
    static bool LocaleInvariantCaseInsensitiveEqual(
        std::string const& lhs,
        std::string const& rhs) noexcept
    {
      auto const rhsSize = rhs.size();
      if (lhs.size() != rhsSize)
      {
        return false;
      }
 
      auto const lhsData = lhs.c_str();
      auto const rhsData = rhs.c_str();
      for (size_t i = 0; i < rhsSize; ++i)
      {
        if (ToLower(lhsData[i]) != ToLower(rhsData[i]))
        {
          return false;
        }
      }
 
      return true;
    }
 
    static std::string ToLower(std::string src)
    {
      std::transform(src.begin(), src.end(), src.begin(), [](auto c) { return ToLower(c); });
      return src;
    }
 
    static std::string ToUpper(std::string src)
    {
      std::transform(src.begin(), src.end(), src.begin(), [](auto c) { return ToUpper(c); });
      return src;
    }
 
    static std::vector<std::string> Split(
        const std::string& s,
        char separator,
        bool removeEmptyEntries = false)
    {
      std::vector<std::string> result;
 
      const auto len = s.size();
      size_t start = 0;
      while (start < len)
      {
        auto end = s.find(separator, start);
        if (end == std::string::npos)
        {
          end = len;
        }
        if (!removeEmptyEntries || start < end)
        {
          result.push_back(s.substr(start, end - start));
        }
 
        start = end + 1;
      }
 
      return result;
    }
 
    static std::string Trim(std::string s)
    {
      s.erase(s.begin(), std::find_if_not(s.begin(), s.end(), IsSpace));
      s.erase(std::find_if_not(s.rbegin(), s.rend(), IsSpace).base(), s.end());
      return s;
    }
  };
 
}}} // namespace Azure::Core::_internal