string.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 TVM_RUNTIME_CONTAINER_STRING_H_
#define TVM_RUNTIME_CONTAINER_STRING_H_
 
#include <dmlc/endian.h>
#include <dmlc/logging.h>
#include <tvm/runtime/container/base.h>
#include <tvm/runtime/logging.h>
#include <tvm/runtime/memory.h>
#include <tvm/runtime/object.h>
 
#include <algorithm>
#include <cstddef>
#include <cstring>
#include <initializer_list>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace tvm {
namespace runtime {
 
// Forward declare TVMArgValue
class TVMArgValue;
 
class StringObj : public Object {
 public:
  const char* data;
 
  uint64_t size;
 
  static constexpr const uint32_t _type_index = TypeIndex::kRuntimeString;
  static constexpr const char* _type_key = "runtime.String";
  TVM_DECLARE_FINAL_OBJECT_INFO(StringObj, Object);
 
 private:
  class FromStd;
 
  friend class String;
};
 
class String : public ObjectRef {
 public:
  String() : String(std::string()) {}
  String(std::string other);  // NOLINT(*)
 
  String(const char* other)  // NOLINT(*)
      : String(std::string(other)) {}
 
  String(std::nullptr_t)  // NOLINT(*)
      : ObjectRef(nullptr) {}
 
  inline String& operator=(std::string other);
 
  inline String& operator=(const char* other);
 
  int compare(const String& other) const {
    return memncmp(data(), other.data(), size(), other.size());
  }
 
  int compare(const std::string& other) const {
    return memncmp(data(), other.data(), size(), other.size());
  }
 
  int compare(const char* other) const {
    return memncmp(data(), other, size(), std::strlen(other));
  }
 
  const char* c_str() const { return get()->data; }
 
  size_t size() const {
    const auto* ptr = get();
    return ptr->size;
  }
 
  size_t length() const { return size(); }
 
  bool empty() const { return size() == 0; }
 
  char at(size_t pos) const {
    if (pos < size()) {
      return data()[pos];
    } else {
      throw std::out_of_range("tvm::String index out of bounds");
    }
  }
 
  const char* data() const { return get()->data; }
 
  operator std::string() const { return std::string{get()->data, size()}; }
 
  inline static bool CanConvertFrom(const TVMArgValue& val);
 
  static uint64_t StableHashBytes(const char* data, size_t size) {
    const constexpr uint64_t kMultiplier = 1099511628211ULL;
    const constexpr uint64_t kMod = 2147483647ULL;
    union Union {
      uint8_t a[8];
      uint64_t b;
    } u;
    static_assert(sizeof(Union) == sizeof(uint64_t), "sizeof(Union) != sizeof(uint64_t)");
    const char* it = data;
    const char* end = it + size;
    uint64_t result = 0;
    for (; it + 8 <= end; it += 8) {
      if (DMLC_IO_NO_ENDIAN_SWAP) {
        u.a[0] = it[0];
        u.a[1] = it[1];
        u.a[2] = it[2];
        u.a[3] = it[3];
        u.a[4] = it[4];
        u.a[5] = it[5];
        u.a[6] = it[6];
        u.a[7] = it[7];
      } else {
        u.a[0] = it[7];
        u.a[1] = it[6];
        u.a[2] = it[5];
        u.a[3] = it[4];
        u.a[4] = it[3];
        u.a[5] = it[2];
        u.a[6] = it[1];
        u.a[7] = it[0];
      }
      result = (result * kMultiplier + u.b) % kMod;
    }
    if (it < end) {
      u.b = 0;
      uint8_t* a = u.a;
      if (it + 4 <= end) {
        a[0] = it[0];
        a[1] = it[1];
        a[2] = it[2];
        a[3] = it[3];
        it += 4;
        a += 4;
      }
      if (it + 2 <= end) {
        a[0] = it[0];
        a[1] = it[1];
        it += 2;
        a += 2;
      }
      if (it + 1 <= end) {
        a[0] = it[0];
        it += 1;
        a += 1;
      }
      if (!DMLC_IO_NO_ENDIAN_SWAP) {
        std::swap(u.a[0], u.a[7]);
        std::swap(u.a[1], u.a[6]);
        std::swap(u.a[2], u.a[5]);
        std::swap(u.a[3], u.a[4]);
      }
      result = (result * kMultiplier + u.b) % kMod;
    }
    return result;
  }
 
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(String, ObjectRef, StringObj);
 
 private:
  static int memncmp(const char* lhs, const char* rhs, size_t lhs_count, size_t rhs_count);
 
  static String Concat(const char* lhs, size_t lhs_size, const char* rhs, size_t rhs_size) {
    std::string ret(lhs, lhs_size);
    ret.append(rhs, rhs_size);
    return String(ret);
  }
 
  // Overload + operator
  friend String operator+(const String& lhs, const String& rhs);
  friend String operator+(const String& lhs, const std::string& rhs);
  friend String operator+(const std::string& lhs, const String& rhs);
  friend String operator+(const String& lhs, const char* rhs);
  friend String operator+(const char* lhs, const String& rhs);
 
  friend struct tvm::runtime::ObjectEqual;
};
 
class StringObj::FromStd : public StringObj {
 public:
  explicit FromStd(std::string other) : data_container{other} {}
 
 private:
  std::string data_container;
 
  friend class String;
};
 
inline String::String(std::string other) {
  auto ptr = make_object<StringObj::FromStd>(std::move(other));
  ptr->size = ptr->data_container.size();
  ptr->data = ptr->data_container.data();
  data_ = std::move(ptr);
}
 
inline String& String::operator=(std::string other) {
  String replace{std::move(other)};
  data_.swap(replace.data_);
  return *this;
}
 
inline String& String::operator=(const char* other) { return operator=(std::string(other)); }
 
inline String operator+(const String& lhs, const String& rhs) {
  size_t lhs_size = lhs.size();
  size_t rhs_size = rhs.size();
  return String::Concat(lhs.data(), lhs_size, rhs.data(), rhs_size);
}
 
inline String operator+(const String& lhs, const std::string& rhs) {
  size_t lhs_size = lhs.size();
  size_t rhs_size = rhs.size();
  return String::Concat(lhs.data(), lhs_size, rhs.data(), rhs_size);
}
 
inline String operator+(const std::string& lhs, const String& rhs) {
  size_t lhs_size = lhs.size();
  size_t rhs_size = rhs.size();
  return String::Concat(lhs.data(), lhs_size, rhs.data(), rhs_size);
}
 
inline String operator+(const char* lhs, const String& rhs) {
  size_t lhs_size = std::strlen(lhs);
  size_t rhs_size = rhs.size();
  return String::Concat(lhs, lhs_size, rhs.data(), rhs_size);
}
 
inline String operator+(const String& lhs, const char* rhs) {
  size_t lhs_size = lhs.size();
  size_t rhs_size = std::strlen(rhs);
  return String::Concat(lhs.data(), lhs_size, rhs, rhs_size);
}
 
// Overload < operator
inline bool operator<(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) < 0; }
 
inline bool operator<(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) > 0; }
 
inline bool operator<(const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
 
inline bool operator<(const String& lhs, const char* rhs) { return lhs.compare(rhs) < 0; }
 
inline bool operator<(const char* lhs, const String& rhs) { return rhs.compare(lhs) > 0; }
 
// Overload > operator
inline bool operator>(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) > 0; }
 
inline bool operator>(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) < 0; }
 
inline bool operator>(const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
 
inline bool operator>(const String& lhs, const char* rhs) { return lhs.compare(rhs) > 0; }
 
inline bool operator>(const char* lhs, const String& rhs) { return rhs.compare(lhs) < 0; }
 
// Overload <= operator
inline bool operator<=(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) <= 0; }
 
inline bool operator<=(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) >= 0; }
 
inline bool operator<=(const String& lhs, const String& rhs) { return lhs.compare(rhs) <= 0; }
 
inline bool operator<=(const String& lhs, const char* rhs) { return lhs.compare(rhs) <= 0; }
 
inline bool operator<=(const char* lhs, const String& rhs) { return rhs.compare(lhs) >= 0; }
 
// Overload >= operator
inline bool operator>=(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) >= 0; }
 
inline bool operator>=(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) <= 0; }
 
inline bool operator>=(const String& lhs, const String& rhs) { return lhs.compare(rhs) >= 0; }
 
inline bool operator>=(const String& lhs, const char* rhs) { return lhs.compare(rhs) >= 0; }
 
inline bool operator>=(const char* lhs, const String& rhs) { return rhs.compare(rhs) <= 0; }
 
// Overload == operator
inline bool operator==(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) == 0; }
 
inline bool operator==(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) == 0; }
 
inline bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; }
 
inline bool operator==(const String& lhs, const char* rhs) { return lhs.compare(rhs) == 0; }
 
inline bool operator==(const char* lhs, const String& rhs) { return rhs.compare(lhs) == 0; }
 
// Overload != operator
inline bool operator!=(const String& lhs, const std::string& rhs) { return lhs.compare(rhs) != 0; }
 
inline bool operator!=(const std::string& lhs, const String& rhs) { return rhs.compare(lhs) != 0; }
 
inline bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; }
 
inline bool operator!=(const String& lhs, const char* rhs) { return lhs.compare(rhs) != 0; }
 
inline bool operator!=(const char* lhs, const String& rhs) { return rhs.compare(lhs) != 0; }
 
inline std::ostream& operator<<(std::ostream& out, const String& input) {
  out.write(input.data(), input.size());
  return out;
}
 
inline int String::memncmp(const char* lhs, const char* rhs, size_t lhs_count, size_t rhs_count) {
  if (lhs == rhs && lhs_count == rhs_count) return 0;
 
  for (size_t i = 0; i < lhs_count && i < rhs_count; ++i) {
    if (lhs[i] < rhs[i]) return -1;
    if (lhs[i] > rhs[i]) return 1;
  }
  if (lhs_count < rhs_count) {
    return -1;
  } else if (lhs_count > rhs_count) {
    return 1;
  } else {
    return 0;
  }
}
 
inline size_t ObjectHash::operator()(const ObjectRef& a) const {
  if (const auto* str = a.as<StringObj>()) {
    return String::StableHashBytes(str->data, str->size);
  }
  return ObjectPtrHash()(a);
}
 
inline bool ObjectEqual::operator()(const ObjectRef& a, const ObjectRef& b) const {
  if (a.same_as(b)) {
    return true;
  }
  if (const auto* str_a = a.as<StringObj>()) {
    if (const auto* str_b = b.as<StringObj>()) {
      return String::memncmp(str_a->data, str_b->data, str_a->size, str_b->size) == 0;
    }
  }
  return false;
}
}  // namespace runtime
 
// expose the functions to the root namespace.
using runtime::String;
using runtime::StringObj;
}  // namespace tvm
 
namespace std {
 
template <>
struct hash<::tvm::runtime::String> {
  std::size_t operator()(const ::tvm::runtime::String& str) const {
    return ::tvm::runtime::String::StableHashBytes(str.data(), str.size());
  }
};
}  // namespace std
 
#endif  // TVM_RUNTIME_CONTAINER_STRING_H_