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

• Show log

  Commit

• Hash : 12c03761
  Author :
  Date : 2018-01-25T12:22:33
  

  Resubmit: Use ImmutableString for HLSL texture references
  
  This fixes an issue in the original revision of this patch by adding
  a operator<< to TInfoSinkBase that takes ImmutableString as a
  parameter.
  
  This also adds ImmutableStringBuilder class, which can be used to
  build ImmutableStrings in place without extra allocations if the
  maximum length is known in advance.
  
  BUG=angleproject:2267
  TEST=angle_unittests
  
  Change-Id: I52e984657a3aba3e6fe67a82b401c6b8de557d18
  Reviewed-on: https://chromium-review.googlesource.com/890522
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/ImmutableString.h

• //
  // Copyright (c) 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 "compiler/translator/Common.h"
  
  namespace sh
  {
  
  namespace
  {
  constexpr size_t constStrlen(const char *str)
  {
      if (str == nullptr)
      {
          return 0u;
      }
      size_t len = 0u;
      while (*(str + len) != '\0')
      {
          ++len;
      }
      return len;
  }
  }
  
  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.
      explicit constexpr ImmutableString(const char *data) : mData(data), mLength(constStrlen(data))
      {
      }
  
      constexpr ImmutableString(const char *data, size_t length) : mData(data), mLength(length) {}
  
      ImmutableString(const ImmutableString &) = default;
      ImmutableString &operator=(const ImmutableString &) = default;
  
      const char *data() const { return mData ? mData : ""; }
      size_t length() const { return mLength; }
  
      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);
      }
  
    private:
      const char *mData;
      size_t mLength;
  };
  
  }  // namespace sh
  
  std::ostream &operator<<(std::ostream &os, const sh::ImmutableString &str);
  
  #endif  // COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  

Download