StringRef.hpp

// Copyright (c) 2018 Graphcore Ltd. All rights reserved.
#ifndef poplar_StringRef_hpp
#define poplar_StringRef_hpp
 
#include <poplar/ArrayRef.hpp>
 
#include <cstring>
#include <iosfwd>
#include <string>
 
namespace poplar {
 
struct StringRef : public ArrayRef<char> {
  constexpr StringRef() : ArrayRef() {}
  constexpr StringRef(const StringRef &) = default;
  StringRef(std::nullptr_t) = delete;
  StringRef(const std::string &s) : ArrayRef(s.data(), s.size()) {}
  constexpr StringRef(const char *p, std::size_t len) : ArrayRef(p, len) {}
  StringRef(const char *p) : ArrayRef(p, std::strlen(p)) {}
 
  // String literal will always be null terminated hence N-1:
  template <std::size_t N>
  constexpr StringRef(const char (&p)[N]) : ArrayRef(p, N - 1) {}
 
  std::string cloneAsString() const { return std::string(begin(), size()); }
 
  operator std::string() const { return cloneAsString(); }
};
 
inline bool operator==(StringRef l, StringRef r) {
  if (l.size() != r.size()) {
    return false;
  }
  return std::strncmp(l.data(), r.data(), l.size()) == 0;
}
 
inline bool operator!=(StringRef l, StringRef r) { return !(l == r); }
 
inline bool operator<(StringRef l, StringRef r) {
  // Include null terminator in comparison in the event one string is the prefix
  // of the other.
  return std::strncmp(l.data(), r.data(), std::min(l.size(), r.size()) + 1) < 0;
}
 
inline std::string operator+(StringRef l, StringRef r) {
  std::string c;
  c.reserve(l.size() + r.size());
  c.append(l);
  c.append(r.data(), r.size());
  return c;
}
 
inline std::string &operator+=(std::string &s, StringRef r) {
  s.append(r.begin(), r.end());
  return s;
}
 
inline std::ostream &operator<<(std::ostream &os, const StringRef &s) {
  return os << s.cloneAsString();
}
 
} // end namespace poplar
 
#endif // poplar_StringRef_hpp