318 lines
7.0 KiB
C++
318 lines
7.0 KiB
C++
//
|
|
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
#pragma once
|
|
|
|
#include "td/utils/Slice-decl.h"
|
|
|
|
#include "td/utils/logging.h"
|
|
|
|
#include <cstring>
|
|
#include <type_traits>
|
|
|
|
namespace td {
|
|
|
|
inline MutableSlice::MutableSlice() : s_(const_cast<char *>("")), len_(0) {
|
|
}
|
|
|
|
inline MutableSlice::MutableSlice(char *s, size_t len) : s_(s), len_(len) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline MutableSlice::MutableSlice(unsigned char *s, size_t len) : s_(reinterpret_cast<char *>(s)), len_(len) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline MutableSlice::MutableSlice(string &s) : MutableSlice() {
|
|
if (!s.empty()) {
|
|
s_ = &s[0];
|
|
len_ = s.size();
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
MutableSlice::MutableSlice(T s, std::enable_if_t<std::is_same<char *, T>::value, private_tag>) : s_(s) {
|
|
CHECK(s_ != nullptr);
|
|
len_ = std::strlen(s_);
|
|
}
|
|
|
|
inline MutableSlice::MutableSlice(char *s, char *t) : MutableSlice(s, t - s) {
|
|
}
|
|
|
|
inline MutableSlice::MutableSlice(unsigned char *s, unsigned char *t) : MutableSlice(s, t - s) {
|
|
}
|
|
|
|
inline size_t MutableSlice::size() const {
|
|
return len_;
|
|
}
|
|
|
|
inline MutableSlice &MutableSlice::remove_prefix(size_t prefix_len) {
|
|
CHECK(prefix_len <= len_);
|
|
s_ += prefix_len;
|
|
len_ -= prefix_len;
|
|
return *this;
|
|
}
|
|
inline MutableSlice &MutableSlice::remove_suffix(size_t suffix_len) {
|
|
CHECK(suffix_len <= len_);
|
|
len_ -= suffix_len;
|
|
return *this;
|
|
}
|
|
|
|
inline MutableSlice &MutableSlice::truncate(size_t size) {
|
|
if (len_ > size) {
|
|
len_ = size;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline MutableSlice MutableSlice::copy() const {
|
|
return *this;
|
|
}
|
|
|
|
inline bool MutableSlice::empty() const {
|
|
return len_ == 0;
|
|
}
|
|
|
|
inline char *MutableSlice::data() const {
|
|
return s_;
|
|
}
|
|
|
|
inline char *MutableSlice::begin() const {
|
|
return s_;
|
|
}
|
|
|
|
inline unsigned char *MutableSlice::ubegin() const {
|
|
return reinterpret_cast<unsigned char *>(s_);
|
|
}
|
|
|
|
inline char *MutableSlice::end() const {
|
|
return s_ + len_;
|
|
}
|
|
|
|
inline unsigned char *MutableSlice::uend() const {
|
|
return reinterpret_cast<unsigned char *>(s_) + len_;
|
|
}
|
|
|
|
inline string MutableSlice::str() const {
|
|
return string(begin(), size());
|
|
}
|
|
|
|
inline MutableSlice MutableSlice::substr(size_t from) const {
|
|
CHECK(from <= len_);
|
|
return MutableSlice(s_ + from, len_ - from);
|
|
}
|
|
inline MutableSlice MutableSlice::substr(size_t from, size_t size) const {
|
|
CHECK(from <= len_);
|
|
return MutableSlice(s_ + from, min(size, len_ - from));
|
|
}
|
|
|
|
inline size_t MutableSlice::find(char c) const {
|
|
for (size_t pos = 0; pos < len_; pos++) {
|
|
if (s_[pos] == c) {
|
|
return pos;
|
|
}
|
|
}
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
|
|
inline size_t MutableSlice::rfind(char c) const {
|
|
for (size_t pos = len_; pos-- > 0;) {
|
|
if (s_[pos] == c) {
|
|
return pos;
|
|
}
|
|
}
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
|
|
inline void MutableSlice::copy_from(Slice from) {
|
|
CHECK(size() >= from.size());
|
|
std::memcpy(ubegin(), from.ubegin(), from.size());
|
|
}
|
|
|
|
inline char &MutableSlice::back() {
|
|
CHECK(1 <= len_);
|
|
return s_[len_ - 1];
|
|
}
|
|
|
|
inline char &MutableSlice::operator[](size_t i) {
|
|
return s_[i];
|
|
}
|
|
|
|
inline Slice::Slice() : s_(""), len_(0) {
|
|
}
|
|
|
|
inline Slice::Slice(const MutableSlice &other) : s_(other.begin()), len_(other.size()) {
|
|
}
|
|
|
|
inline Slice::Slice(const char *s, size_t len) : s_(s), len_(len) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline Slice::Slice(const unsigned char *s, size_t len) : s_(reinterpret_cast<const char *>(s)), len_(len) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline Slice::Slice(const string &s) : s_(s.c_str()), len_(s.size()) {
|
|
}
|
|
|
|
template <class T>
|
|
Slice::Slice(T s, std::enable_if_t<std::is_same<char *, std::remove_const_t<T>>::value, private_tag>) : s_(s) {
|
|
CHECK(s_ != nullptr);
|
|
len_ = std::strlen(s_);
|
|
}
|
|
|
|
template <class T>
|
|
Slice::Slice(T s, std::enable_if_t<std::is_same<const char *, std::remove_const_t<T>>::value, private_tag>) : s_(s) {
|
|
CHECK(s_ != nullptr);
|
|
len_ = std::strlen(s_);
|
|
}
|
|
|
|
inline Slice::Slice(const char *s, const char *t) : s_(s), len_(t - s) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline Slice::Slice(const unsigned char *s, const unsigned char *t)
|
|
: s_(reinterpret_cast<const char *>(s)), len_(t - s) {
|
|
CHECK(s_ != nullptr);
|
|
}
|
|
|
|
inline size_t Slice::size() const {
|
|
return len_;
|
|
}
|
|
|
|
inline Slice &Slice::remove_prefix(size_t prefix_len) {
|
|
CHECK(prefix_len <= len_);
|
|
s_ += prefix_len;
|
|
len_ -= prefix_len;
|
|
return *this;
|
|
}
|
|
|
|
inline Slice &Slice::remove_suffix(size_t suffix_len) {
|
|
CHECK(suffix_len <= len_);
|
|
len_ -= suffix_len;
|
|
return *this;
|
|
}
|
|
|
|
inline Slice &Slice::truncate(size_t size) {
|
|
if (len_ > size) {
|
|
len_ = size;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline Slice Slice::copy() const {
|
|
return *this;
|
|
}
|
|
|
|
inline bool Slice::empty() const {
|
|
return len_ == 0;
|
|
}
|
|
|
|
inline const char *Slice::data() const {
|
|
return s_;
|
|
}
|
|
|
|
inline const char *Slice::begin() const {
|
|
return s_;
|
|
}
|
|
|
|
inline const unsigned char *Slice::ubegin() const {
|
|
return reinterpret_cast<const unsigned char *>(s_);
|
|
}
|
|
|
|
inline const char *Slice::end() const {
|
|
return s_ + len_;
|
|
}
|
|
|
|
inline const unsigned char *Slice::uend() const {
|
|
return reinterpret_cast<const unsigned char *>(s_) + len_;
|
|
}
|
|
|
|
inline string Slice::str() const {
|
|
return string(begin(), size());
|
|
}
|
|
|
|
inline Slice Slice::substr(size_t from) const {
|
|
CHECK(from <= len_);
|
|
return Slice(s_ + from, len_ - from);
|
|
}
|
|
inline Slice Slice::substr(size_t from, size_t size) const {
|
|
CHECK(from <= len_);
|
|
return Slice(s_ + from, min(size, len_ - from));
|
|
}
|
|
|
|
inline size_t Slice::find(char c) const {
|
|
for (size_t pos = 0; pos < len_; pos++) {
|
|
if (s_[pos] == c) {
|
|
return pos;
|
|
}
|
|
}
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
|
|
inline size_t Slice::rfind(char c) const {
|
|
for (size_t pos = len_; pos-- > 0;) {
|
|
if (s_[pos] == c) {
|
|
return pos;
|
|
}
|
|
}
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
|
|
inline char Slice::back() const {
|
|
CHECK(1 <= len_);
|
|
return s_[len_ - 1];
|
|
}
|
|
|
|
inline char Slice::operator[](size_t i) const {
|
|
return s_[i];
|
|
}
|
|
|
|
inline bool operator==(const Slice &a, const Slice &b) {
|
|
return a.size() == b.size() && std::memcmp(a.data(), b.data(), a.size()) == 0;
|
|
}
|
|
|
|
inline bool operator!=(const Slice &a, const Slice &b) {
|
|
return !(a == b);
|
|
}
|
|
|
|
inline bool operator<(const Slice &a, const Slice &b) {
|
|
auto x = std::memcmp(a.data(), b.data(), td::min(a.size(), b.size()));
|
|
if (x == 0) {
|
|
return a.size() < b.size();
|
|
}
|
|
return x < 0;
|
|
}
|
|
|
|
inline MutableCSlice::MutableCSlice(char *s, char *t) : MutableSlice(s, t) {
|
|
CHECK(*t == '\0');
|
|
}
|
|
|
|
inline CSlice::CSlice(const char *s, const char *t) : Slice(s, t) {
|
|
CHECK(*t == '\0');
|
|
}
|
|
|
|
inline std::size_t SliceHash::operator()(Slice slice) const {
|
|
// simple string hash
|
|
std::size_t result = 0;
|
|
constexpr std::size_t MUL = 123456789;
|
|
for (auto c : slice) {
|
|
result = result * MUL + c;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template <size_t N>
|
|
td::Slice as_slice(const td::UInt<N> &value) {
|
|
return td::Slice(value.raw, N / 8);
|
|
}
|
|
template <size_t N>
|
|
td::MutableSlice as_slice(td::UInt<N> &value) {
|
|
return td::MutableSlice(value.raw, N / 8);
|
|
}
|
|
|
|
} // namespace td
|