vector_ref.h

Go to the documentation of this file.

// Aleth: Ethereum C++ client, tools and libraries.
// Copyright 2014-2019 Aleth Authors.
// Licensed under the GNU General Public License, Version 3.
#pragma once
 
#include <atomic>
#include <cassert>
#include <cstring>
#include <string>
#include <type_traits>
#include <vector>
 
#ifdef __INTEL_COMPILER
#pragma warning(disable : 597)  // will not be called for implicit or explicit conversions
#endif
 
namespace dev {
 
template <class _T>
class vector_ref {
 public:
  using value_type = _T;
  using element_type = _T;
  using mutable_value_type =
      typename std::conditional<std::is_const<_T>::value, typename std::remove_const<_T>::type, _T>::type;
 
  static_assert(std::is_standard_layout<value_type>::value,
                "vector_ref can only be used with PODs due to its low-level "
                "treatment of data.");
 
  vector_ref() : m_data(nullptr), m_count(0) {}
  vector_ref(_T* _data, size_t _count) : m_data(_data), m_count(_count) {}
  vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const*, std::string*>::type _data)
      : m_data(reinterpret_cast<_T*>(_data->data())), m_count(_data->size() / sizeof(_T)) {}
  vector_ref(
      typename std::conditional<std::is_const<_T>::value, std::vector<typename std::remove_const<_T>::type> const*,
                                std::vector<_T>*>::type _data)
      : m_data(_data->data()), m_count(_data->size()) {}
  vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data)
      : m_data(reinterpret_cast<_T*>(_data.data())), m_count(_data.size() / sizeof(_T)) {}
  explicit operator bool() const { return m_data && m_count; }
 
  bool contentsEqual(std::vector<mutable_value_type> const& _c) const {
    if (!m_data || m_count == 0)
      return _c.empty();
    else
      return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count * sizeof(_T));
  }
  std::vector<mutable_value_type> toVector() const { return std::vector<mutable_value_type>(m_data, m_data + m_count); }
  std::vector<unsigned char> toBytes() const {
    return std::vector<unsigned char>(reinterpret_cast<unsigned char const*>(m_data),
                                      reinterpret_cast<unsigned char const*>(m_data) + m_count * sizeof(_T));
  }
  std::string toString() const {
    return std::string((char const*)m_data, ((char const*)m_data) + m_count * sizeof(_T));
  }
 
  template <class _T2>
  explicit operator vector_ref<_T2>() const {
    assert(m_count * sizeof(_T) / sizeof(_T2) * sizeof(_T2) / sizeof(_T) == m_count);
    return vector_ref<_T2>(reinterpret_cast<_T2*>(m_data), m_count * sizeof(_T) / sizeof(_T2));
  }
  operator vector_ref<_T const>() const { return vector_ref<_T const>(m_data, m_count); }
 
  _T* data() const { return m_data; }
  size_t count() const { return m_count; }
  size_t size() const { return m_count; }
  bool empty() const { return !m_count; }
  vector_ref<_T> next() const {
    if (!m_data)
      return *this;
    else
      return vector_ref<_T>(m_data + m_count, m_count);
  }
  vector_ref<_T> cropped(size_t _begin, size_t _count) const {
    if (m_data && _begin <= m_count && _count <= m_count && _begin + _count <= m_count)
      return vector_ref<_T>(m_data + _begin, _count == ~size_t(0) ? m_count - _begin : _count);
    else
      return vector_ref<_T>();
  }
  vector_ref<_T> cropped(size_t _begin) const {
    if (m_data && _begin <= m_count)
      return vector_ref<_T>(m_data + _begin, m_count - _begin);
    else
      return vector_ref<_T>();
  }
  void retarget(_T* _d, size_t _s) {
    m_data = _d;
    m_count = _s;
  }
  void retarget(std::vector<_T> const& _t) {
    m_data = _t.data();
    m_count = _t.size();
  }
  template <class T>
  bool overlapsWith(vector_ref<T> _t) const {
    void const* f1 = data();
    void const* t1 = data() + size();
    void const* f2 = _t.data();
    void const* t2 = _t.data() + _t.size();
    return f1 < t2 && t1 > f2;
  }
  void copyTo(vector_ref<typename std::remove_const<_T>::type> _t) const {
    if (overlapsWith(_t))
      memmove(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T));
    else
      memcpy(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T));
  }
  void populate(vector_ref<typename std::remove_const<_T>::type> _t) const {
    copyTo(_t);
    memset(_t.data() + m_count, 0, std::max(_t.size(), m_count) - m_count);
  }
  void cleanse() {
    static std::atomic<unsigned char> s_cleanseCounter{0u};
    uint8_t* p = (uint8_t*)begin();
    size_t const len = (uint8_t*)end() - p;
    size_t loop = len;
    size_t counter = s_cleanseCounter;
    while (loop--) {
      *(p++) = (uint8_t)counter;
      counter += (17 + ((size_t)p & 0xf));
    }
    p = (uint8_t*)memchr((uint8_t*)begin(), (uint8_t)counter, len);
    if (p) counter += (63 + (size_t)p);
    s_cleanseCounter = (uint8_t)counter;
    memset((uint8_t*)begin(), 0, len);
  }
 
  _T* begin() { return m_data; }
  _T* end() { return m_data + m_count; }
  _T const* begin() const { return m_data; }
  _T const* end() const { return m_data + m_count; }
 
  _T& operator[](size_t _i) {
    assert(m_data);
    assert(_i < m_count);
    return m_data[_i];
  }
  _T const& operator[](size_t _i) const {
    assert(m_data);
    assert(_i < m_count);
    return m_data[_i];
  }
 
  bool operator==(vector_ref<_T> const& _cmp) const { return m_data == _cmp.m_data && m_count == _cmp.m_count; }
  bool operator!=(vector_ref<_T> const& _cmp) const { return !operator==(_cmp); }
 
  void reset() {
    m_data = nullptr;
    m_count = 0;
  }
 
 private:
  _T* m_data;
  size_t m_count;
};
 
template <class _T>
vector_ref<_T const> ref(_T const& _t) {
  return vector_ref<_T const>(&_t, 1);
}
template <class _T>
vector_ref<_T> ref(_T& _t) {
  return vector_ref<_T>(&_t, 1);
}
template <class _T>
vector_ref<_T const> ref(std::vector<_T> const& _t) {
  return vector_ref<_T const>(&_t);
}
template <class _T>
vector_ref<_T> ref(std::vector<_T>& _t) {
  return vector_ref<_T>(&_t);
}
 
}  // namespace dev