ExposedVector.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Chris Bielow $
// $Authors: Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
 
#include <cstddef>   // for size_t
#include <vector>
#include <algorithm>
#include <concepts>
 
namespace OpenMS
{
  template<typename T>
  concept LessThanComparable = requires(const T& a, const T& b) { // less and greater
      { a < b } -> std::convertible_to<bool>;
  };
 
 
#define EXPOSED_VECTOR_INTERFACE(InnerElement) \
    using ExpVec = ExposedVector< InnerElement >;                     \
    using ExpVec::ExposedVector;                                               \
    using value_type = typename ExpVec::value_type;                            \
    using iterator = typename ExpVec::iterator;                                \
    using const_iterator = typename ExpVec::const_iterator;                    \
    using reverse_iterator = typename ExpVec::reverse_iterator;                \
    using const_reverse_iterator = typename ExpVec::const_reverse_iterator;    \
    using size_type = typename ExpVec::size_type;                              \
    using pointer = typename ExpVec::pointer;                                  \
    using reference = typename ExpVec::reference;                              \
    using const_reference = typename ExpVec::const_reference;                  \
    using difference_type = typename ExpVec::difference_type;                  \
 
 
  template<class VectorElement>
  class ExposedVector
  {
  public: 
    using VecMember = std::vector<VectorElement>;
 
    // types
    using value_type = typename VecMember::value_type;
    using iterator = typename VecMember::iterator;
    using const_iterator = typename VecMember::const_iterator;
    using reverse_iterator = typename VecMember::reverse_iterator;
    using const_reverse_iterator = typename VecMember::const_reverse_iterator;
    using size_type = typename VecMember::size_type;
    using pointer = typename VecMember::pointer;
    using reference = typename VecMember::reference;
    using const_reference = typename VecMember::const_reference;
    using difference_type = typename VecMember::difference_type;
 
  protected:
    VecMember data_; 
 
  public:
    ExposedVector() = default;
    explicit ExposedVector(const size_t n)
      : data_(n)
    {
    }
    ExposedVector(const size_t n, const VectorElement& val) : data_(n, val)
    {
    }
    template <class Iter> ExposedVector(Iter begin, Iter end) 
      : data_(begin, end)
    {
    }
    ExposedVector(const ExposedVector& rhs) = default;
    ExposedVector(ExposedVector&& rhs) noexcept = default;
 
    ExposedVector& operator=(const ExposedVector& rhs) = default;
    ExposedVector& operator=(ExposedVector&& rhs) noexcept = default;
 
    iterator begin() noexcept
    {
      return data_.begin();
    }
    iterator end() noexcept
    {
      return data_.end();
    }
    const_iterator begin() const noexcept
    {
      return data_.begin();
    }
    const_iterator end() const noexcept
    {
      return data_.end();
    }
    const_iterator cbegin() const noexcept
    {
      return data_.cbegin();
    }
    const_iterator cend() const noexcept
    {
      return data_.cend();
    }
    size_t size() const noexcept
    {
      return data_.size();
    }
    void resize(const size_t new_size)
    {
      data_.resize(new_size);
    }
    void reserve(const size_t new_size)
    {
      data_.reserve(new_size);
    }
    bool empty() const noexcept
    {
      return data_.empty();
    }
    VectorElement& operator[](size_t i) noexcept
    {
      return data_[i];
    }
    const VectorElement& operator[](size_t i) const noexcept
    {
      return data_[i];
    }
    VectorElement& at(size_t i)
    {
      return data_.at(i);
    }
    const VectorElement& at(size_t i) const
    {
      return data_.at(i);
    }
    VectorElement& back() noexcept
    {
      return data_.back();
    }
    const VectorElement& back() const noexcept
    {
      return data_.back();
    }
    void push_back(const VectorElement& f)
    {
      data_.push_back(f);
    }
    void push_back(VectorElement&& f)
    {
      data_.push_back(std::move(f));
    }
    template<typename... Args>
    decltype(auto) emplace_back(Args&&... args)
    {
      return data_.emplace_back(std::forward<Args>(args)...);
    }
    void pop_back() noexcept
    {
      data_.pop_back();
    }
    iterator erase(const_iterator where) noexcept
    {
      return data_.erase(where);
    }
    iterator erase(const_iterator from, const_iterator to) noexcept
    {
      return data_.erase(from, to);
    }
    template<typename T>
    iterator insert(const_iterator where, T from, T to)
    {
      return data_.insert(where, from, to);
    }
    
    void clear() noexcept
    {
      data_.clear();
    }
    
    reverse_iterator rbegin() noexcept
    {
      return data_.rbegin();
    }
    
    const_reverse_iterator rbegin() const noexcept
    {
      return data_.rbegin();
    }
    
    reverse_iterator rend() noexcept
    {
      return data_.rend();
    }
    
    const_reverse_iterator rend() const noexcept
    {
      return data_.rend();
    }
    
    const_reverse_iterator crbegin() const noexcept
    {
      return data_.crbegin();
    }
    
    const_reverse_iterator crend() const noexcept
    {
      return data_.crend();
    }
    
    void swap(ExposedVector& other) noexcept
    {
      data_.swap(other.data_);
    }
    
    template<typename InputIt>
    void assign(InputIt first, InputIt last)
    {
      data_.assign(first, last);
    }
    
    void assign(size_type count, const VectorElement& value)
    {
      data_.assign(count, value);
    }
    
    void assign(std::initializer_list<VectorElement> init)
    {
      data_.assign(init);
    }
    
    VectorElement& front() noexcept
    {
      return data_.front();
    }
    
    const VectorElement& front() const noexcept
    {
      return data_.front();
    }
    
    size_type max_size() const noexcept
    {
      return data_.max_size();
    }
    
    size_type capacity() const noexcept
    {
      return data_.capacity();
    }
    
    void shrink_to_fit()
    {
      data_.shrink_to_fit();
    }
    
    iterator insert(const_iterator pos, const VectorElement& value)
    {
      return data_.insert(pos, value);
    }
    
    iterator insert(const_iterator pos, VectorElement&& value)
    {
      return data_.insert(pos, std::move(value));
    }
    
    iterator insert(const_iterator pos, size_type count, const VectorElement& value)
    {
      return data_.insert(pos, count, value);
    }
    
    iterator insert(const_iterator pos, std::initializer_list<VectorElement> init)
    {
      return data_.insert(pos, init);
    }
    
    template<typename... Args>
    iterator emplace(const_iterator pos, Args&&... args)
    {
      return data_.emplace(pos, std::forward<Args>(args)...);
    }
 
    const VecMember& getData() const
    {
      return data_;
    }
    VecMember& getData()
    {
      return data_;
    }
    
    bool operator==(const ExposedVector& other) const
    {
      return data_ == other.data_;
    }
    
    bool operator!=(const ExposedVector& other) const
    {
      return data_ != other.data_;
    }
    
    // Define operators only if underlying vector supports them
    bool operator<(const ExposedVector& other) const requires LessThanComparable<VectorElement>
    {
        return data_ < other.data_;
    }
 
    bool operator<=(const ExposedVector& other) const requires LessThanComparable<VectorElement>
    {
        return data_ <= other.data_;
    }
 
    bool operator>(const ExposedVector& other) const requires LessThanComparable<VectorElement>
    {
        return data_ > other.data_;
    }
 
    bool operator>=(const ExposedVector& other) const requires LessThanComparable<VectorElement>
    {
        return data_ >= other.data_;
    }
   };
} // namespace OpenMS