kc3-lang/angle/src/compiler/translator/ImmutableString.h

• Show log

  Commit

• Hash : 96f44329
  Author :
  Date : 2024-03-25T14:16:10
  

  Revert "Remove few redundant ImmutableString to std::string conversions"
  
  This reverts commit ebb94b807f184f2d36cb0843c429667cd80e0675.
  
  Reason for revert: Needs a different implementation of
  std::string::size() to pass C++17 compilers.
  
  Original change's description:
  > Remove few redundant ImmutableString to std::string conversions
  >
  > Maybe removes few strlen calls.
  >
  > Bug: angleproject:8614
  > Change-Id: I4fbb5f6abb8e8d21ff44a34975bab379127a0a11
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5372715
  > Auto-Submit: Kimmo Kinnunen <kkinnunen@apple.com>
  > Commit-Queue: Geoff Lang <geofflang@chromium.org>
  > Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  > Reviewed-by: Geoff Lang <geofflang@chromium.org>
  
  Bug: angleproject:8614
  Change-Id: I1a635b74674a2e1b635972bb4372c43340527a2f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5391900
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Auto-Submit: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/compiler/translator/ImmutableString.h

• //
  // Copyright 2018 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // ImmutableString.h: Wrapper for static or pool allocated char arrays, that are guaranteed to be
  // valid and unchanged for the duration of the compilation.
  //
  
  #ifndef COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  #define COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  
  #include <string>
  
  #include "common/string_utils.h"
  #include "common/utilities.h"
  #include "compiler/translator/Common.h"
  
  namespace sh
  {
  
  class ImmutableString
  {
    public:
      // The data pointer passed in must be one of:
      //  1. nullptr (only valid with length 0).
      //  2. a null-terminated static char array like a string literal.
      //  3. a null-terminated pool allocated char array. This can't be c_str() of a local TString,
      //     since when a TString goes out of scope it clears its first character.
      explicit constexpr ImmutableString(const char *data)
          : mData(data), mLength(angle::ConstStrLen(data))
      {}
  
      constexpr ImmutableString(const char *data, size_t length) : mData(data), mLength(length) {}
  
      ImmutableString(const std::string &str)
          : mData(AllocatePoolCharArray(str.c_str(), str.size())), mLength(str.size())
      {}
  
      constexpr ImmutableString(const ImmutableString &) = default;
  
      ImmutableString &operator=(const ImmutableString &) = default;
  
      constexpr const char *data() const { return mData ? mData : ""; }
      constexpr size_t length() const { return mLength; }
  
      char operator[](size_t index) const { return data()[index]; }
  
      constexpr bool empty() const { return mLength == 0; }
      constexpr bool beginsWith(const char *prefix) const
      {
          return beginsWith(ImmutableString(prefix));
      }
      constexpr bool beginsWith(const ImmutableString &prefix) const
      {
          return mLength >= prefix.length() && memcmp(data(), prefix.data(), prefix.length()) == 0;
      }
      bool contains(const char *substr) const { return strstr(data(), substr) != nullptr; }
  
      constexpr bool operator==(const ImmutableString &b) const
      {
          if (mLength != b.mLength)
          {
              return false;
          }
          return memcmp(data(), b.data(), mLength) == 0;
      }
      constexpr bool operator!=(const ImmutableString &b) const { return !(*this == b); }
      constexpr bool operator==(const char *b) const
      {
          if (b == nullptr)
          {
              return empty();
          }
          return strcmp(data(), b) == 0;
      }
      constexpr bool operator!=(const char *b) const { return !(*this == b); }
      bool operator==(const std::string &b) const
      {
          return mLength == b.length() && memcmp(data(), b.c_str(), mLength) == 0;
      }
      bool operator!=(const std::string &b) const { return !(*this == b); }
  
      constexpr bool operator<(const ImmutableString &b) const
      {
          if (mLength < b.mLength)
          {
              return true;
          }
          if (mLength > b.mLength)
          {
              return false;
          }
          return (memcmp(data(), b.data(), mLength) < 0);
      }
  
      template <size_t hashBytes>
      struct FowlerNollVoHash
      {
          static const size_t kFnvOffsetBasis;
          static const size_t kFnvPrime;
  
          constexpr size_t operator()(const ImmutableString &a) const
          {
              const char *data = a.data();
              size_t hash      = kFnvOffsetBasis;
              while ((*data) != '\0')
              {
                  hash = hash ^ (*data);
                  hash = hash * kFnvPrime;
                  ++data;
              }
              return hash;
          }
      };
  
      // Perfect hash functions
      uint32_t mangledNameHash() const;
      uint32_t unmangledNameHash() const;
  
    private:
      const char *mData;
      size_t mLength;
  };
  
  constexpr ImmutableString kEmptyImmutableString("");
  }  // namespace sh
  
  std::ostream &operator<<(std::ostream &os, const sh::ImmutableString &str);
  
  #endif  // COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  

Download