Vector.h

#pragma once
#include <stddef.h>
#include <stdint.h>
#include "TransceiverConfig.h"
#if defined(HAS_STL)
#  include <vector>
#endif
namespace pulsewire {
 
#if defined(HAS_STL)
 
// Use global std::vector, not pulsewire::std
template <typename T>
using Vector = ::std::vector<T>;
 
#else
 
template <typename T>
class Vector {
 public:
  using value_type = T;
  using iterator = T*;
  using const_iterator = const T*;
 
  Vector() : _data(nullptr), _size(0), _capacity(0) {}
 
  explicit Vector(size_t n) : _data(nullptr), _size(0), _capacity(0) {
    resize(n);
  }
 
  Vector(const Vector& other) : _data(nullptr), _size(0), _capacity(0) {
    if (other._size) {
      reserve(other._size);
      for (size_t i = 0; i < other._size; ++i) _data[i] = other._data[i];
      _size = other._size;
    }
  }
 
  Vector(Vector&& other) noexcept
      : _data(other._data), _size(other._size), _capacity(other._capacity) {
    other._data = nullptr;
    other._size = 0;
    other._capacity = 0;
  }
 
  Vector& operator=(const Vector& other) {
    if (this != &other) {
      clear();
      reserve(other._size);
      for (size_t i = 0; i < other._size; ++i) _data[i] = other._data[i];
      _size = other._size;
    }
    return *this;
  }
 
  Vector& operator=(Vector&& other) noexcept {
    if (this != &other) {
      delete[] _data;
      _data = other._data;
      _size = other._size;
      _capacity = other._capacity;
      other._data = nullptr;
      other._size = 0;
      other._capacity = 0;
    }
    return *this;
  }
 
  ~Vector() { delete[] _data; }
 
  void push_back(const T& value) {
    if (_size >= _capacity) reserve(_capacity ? _capacity * 2 : 4);
    _data[_size++] = value;
  }
  iterator begin() { return _data; }
  iterator end() { return _data + _size; }
  const_iterator begin() const { return _data; }
  const_iterator end() const { return _data + _size; }
 
  T* data() { return _data; }
  const T* data() const { return _data; }
 
  T& operator[](size_t idx) { return _data[idx]; }
  const T& operator[](size_t idx) const { return _data[idx]; }
 
  size_t size() const { return _size; }
  bool empty() const { return _size == 0; }
  void clear() { _size = 0; }
 
  T& back() { return _data[_size - 1]; }
  const T& back() const { return _data[_size - 1]; }
 
  iterator erase(iterator pos) {
    size_t idx = pos - _data;
    if (idx >= _size) return end();
    for (size_t i = idx; i + 1 < _size; ++i) _data[i] = _data[i + 1];
    --_size;
    return _data + idx;
  }
 
  iterator erase(iterator first, iterator last) {
    if (first >= last) return first;
    size_t idx = first - _data;
    size_t idx2 = last - _data;
    if (idx >= _size) return end();
    if (idx2 > _size) idx2 = _size;
    size_t count = idx2 - idx;
    for (size_t i = idx; i + count < _size; ++i) _data[i] = _data[i + count];
    _size -= count;
    return _data + idx;
  }
 
  void resize(size_t n) {
    if (n > _capacity) reserve(n);
    for (size_t i = _size; i < n; ++i) _data[i] = T();
    _size = n;
  }
 
  void reserve(size_t cap) {
    if (cap <= _capacity) return;
    T* new_data = new T[cap];
    for (size_t i = 0; i < _size; ++i) new_data[i] = _data[i];
    delete[] _data;
    _data = new_data;
    _capacity = cap;
  }
 
  size_t capacity() const { return _capacity; }
 
 private:
  T* _data;
  size_t _size;
  size_t _capacity;
};
 
#endif
}  // namespace pulsewire