initial commit

tdutils/td/utils/Slice-decl.h

@@ -0,0 +1,224 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#pragma once
+
+#include "td/utils/common.h"
+
+#include <type_traits>
+
+namespace td {
+
+class Slice;
+
+class MutableSlice {
+  char *s_;
+  size_t len_;
+
+  struct private_tag {};
+
+ public:
+  MutableSlice();
+  MutableSlice(char *s, size_t len);
+  MutableSlice(unsigned char *s, size_t len);
+  MutableSlice(string &s);
+  template <class T>
+  explicit MutableSlice(T s, std::enable_if_t<std::is_same<char *, T>::value, private_tag> = {});
+  MutableSlice(char *s, char *t);
+  MutableSlice(unsigned char *s, unsigned char *t);
+  template <size_t N>
+  constexpr MutableSlice(char (&a)[N]) = delete;
+
+  bool empty() const;
+  size_t size() const;
+
+  MutableSlice &remove_prefix(size_t prefix_len);
+  MutableSlice &remove_suffix(size_t suffix_len);
+  MutableSlice &truncate(size_t size);
+
+  MutableSlice copy() const;
+
+  char *data() const;
+  char *begin() const;
+  unsigned char *ubegin() const;
+  char *end() const;
+  unsigned char *uend() const;
+
+  string str() const;
+  MutableSlice substr(size_t from) const;
+  MutableSlice substr(size_t from, size_t size) const;
+  size_t find(char c) const;
+  size_t rfind(char c) const;
+  void fill(char c);
+  void fill_zero();
+  void fill_zero_secure();
+
+  void copy_from(Slice from);
+
+  char &back();
+  char &operator[](size_t i);
+
+  static const size_t npos = string::npos;
+};
+
+class Slice {
+  const char *s_;
+  size_t len_;
+
+  struct private_tag {};
+
+ public:
+  Slice();
+  Slice(const MutableSlice &other);
+  Slice(const char *s, size_t len);
+  Slice(const unsigned char *s, size_t len);
+  Slice(const string &s);
+  template <class T>
+  explicit Slice(T s, std::enable_if_t<std::is_same<char *, std::remove_const_t<T>>::value, private_tag> = {});
+  template <class T>
+  explicit Slice(T s, std::enable_if_t<std::is_same<const char *, std::remove_const_t<T>>::value, private_tag> = {});
+  Slice(const char *s, const char *t);
+  Slice(const unsigned char *s, const unsigned char *t);
+
+  template <size_t N>
+  constexpr Slice(char (&a)[N]) = delete;
+
+  template <size_t N>
+  constexpr Slice(const char (&a)[N]) : s_(a), len_(N - 1) {
+  }
+
+  Slice &operator=(string &&s) = delete;
+
+  template <size_t N>
+  constexpr Slice &operator=(char (&a)[N]) = delete;
+
+  template <size_t N>
+  constexpr Slice &operator=(const char (&a)[N]) {
+    s_ = a;
+    len_ = N - 1;
+    return *this;
+  }
+
+  bool empty() const;
+  size_t size() const;
+
+  Slice &remove_prefix(size_t prefix_len);
+  Slice &remove_suffix(size_t suffix_len);
+  Slice &truncate(size_t size);
+
+  Slice copy() const;
+
+  const char *data() const;
+  const char *begin() const;
+  const unsigned char *ubegin() const;
+  const char *end() const;
+  const unsigned char *uend() const;
+
+  string str() const;
+  Slice substr(size_t from) const;
+  Slice substr(size_t from, size_t size) const;
+  size_t find(char c) const;
+  size_t rfind(char c) const;
+
+  char back() const;
+  char operator[](size_t i) const;
+
+  static const size_t npos = string::npos;
+};
+
+bool operator==(const Slice &a, const Slice &b);
+bool operator!=(const Slice &a, const Slice &b);
+bool operator<(const Slice &a, const Slice &b);
+
+class MutableCSlice : public MutableSlice {
+  struct private_tag {};
+
+  MutableSlice &remove_suffix(size_t suffix_len) = delete;
+  MutableSlice &truncate(size_t size) = delete;
+
+ public:
+  MutableCSlice() = delete;
+  MutableCSlice(string &s) : MutableSlice(s) {
+  }
+  template <class T>
+  explicit MutableCSlice(T s, std::enable_if_t<std::is_same<char *, T>::value, private_tag> = {}) : MutableSlice(s) {
+  }
+  MutableCSlice(char *s, char *t);
+
+  template <size_t N>
+  constexpr MutableCSlice(char (&a)[N]) = delete;
+
+  const char *c_str() const {
+    return begin();
+  }
+};
+
+class CSlice : public Slice {
+  struct private_tag {};
+
+  Slice &remove_suffix(size_t suffix_len) = delete;
+  Slice &truncate(size_t size) = delete;
+
+ public:
+  explicit CSlice(const MutableSlice &other) : Slice(other) {
+  }
+  CSlice(const MutableCSlice &other) : Slice(other.begin(), other.size()) {
+  }
+  CSlice(const string &s) : Slice(s) {
+  }
+  template <class T>
+  explicit CSlice(T s, std::enable_if_t<std::is_same<char *, std::remove_const_t<T>>::value, private_tag> = {})
+      : Slice(s) {
+  }
+  template <class T>
+  explicit CSlice(T s, std::enable_if_t<std::is_same<const char *, std::remove_const_t<T>>::value, private_tag> = {})
+      : Slice(s) {
+  }
+  CSlice(const char *s, const char *t);
+
+  template <size_t N>
+  constexpr CSlice(char (&a)[N]) = delete;
+
+  template <size_t N>
+  constexpr CSlice(const char (&a)[N]) : Slice(a) {
+  }
+
+  CSlice() : CSlice("") {
+  }
+
+  CSlice &operator=(string &&s) = delete;
+
+  template <size_t N>
+  constexpr CSlice &operator=(char (&a)[N]) = delete;
+
+  template <size_t N>
+  constexpr CSlice &operator=(const char (&a)[N]) {
+    this->Slice::operator=(a);
+    return *this;
+  }
+
+  const char *c_str() const {
+    return begin();
+  }
+};
+
+struct SliceHash {
+  std::size_t operator()(Slice slice) const;
+};
+
+}  // namespace td