Vector.hpp

Go to the documentation of this file.

#ifndef RAIIGRAPH_VECTOR_HPP
#define RAIIGRAPH_VECTOR_HPP
 
#include "igraph.h"
#include "error.hpp"
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
 
namespace raiigraph {
 
template<class Ns_>
class Vector {
private:
    void setup(igraph_int_t size) {
        check_code(Ns_::init(&my_vector, size));
    }
 
public:
    typedef typename Ns_::igraph_type igraph_type;
 
    typedef typename Ns_::value_type value_type;
 
    typedef value_type& reference;
 
    typedef const value_type& const_reference;
 
    typedef igraph_int_t size_type;
 
    typedef igraph_int_t difference_type;
 
    typedef value_type* iterator;
 
    typedef const value_type* const_iterator;
 
    typedef std::reverse_iterator<iterator> reverse_iterator;
 
    typedef std::reverse_iterator<const_iterator> reverse_const_iterator;
 
public:
    Vector() : Vector(0) {}
 
    Vector(size_type size, const value_type& val = value_type()) {
        setup(size);
        std::fill_n(begin(), size, val);
    }
 
    Vector(igraph_type&& vector) : my_vector(std::move(vector)) {}
 
    template<typename InputIterator, typename = decltype(*std::declval<InputIterator>())> // use SFINAE to avoid ambiguity with other 2-argument constructors.
    Vector(InputIterator first, InputIterator last) : Vector(last - first) {
        std::copy(first, last, begin());
    }
 
public:
    Vector(const Vector<Ns_>& other) {
        check_code(Ns_::copy(&my_vector, &(other.my_vector)));
    }
 
    Vector<Ns_>& operator=(const Vector<Ns_>& other) {
        if (this != &other) {
            // my_vector should already be initialized before the assignment.
            check_code(Ns_::update(&my_vector, &(other.my_vector)));
        }
        return *this;
    }
 
    Vector(Vector<Ns_>&& other) {
        setup(0); // we must leave 'other' in a valid state.
        std::swap(my_vector, other.my_vector);
    }
 
    Vector& operator=(Vector<Ns_>&& other) {
        if (this != &other) {
            std::swap(my_vector, other.my_vector); // 'my_vector' should already be initialized, so we're leaving 'other' in a valid state.
        }
        return *this;
    }
 
    ~Vector() {
        Ns_::destroy(&my_vector);
    }
 
public:
    igraph_bool_t empty() const {
        return Ns_::empty(&my_vector);
    }
 
    size_type size() const {
        return Ns_::size(&my_vector);
    }
 
    constexpr size_type max_size() const { return IGRAPH_INTEGER_MAX; }
 
    size_type capacity() const {
        return my_vector.stor_end - my_vector.stor_begin;
    }
 
    void clear() {
        Ns_::clear(&my_vector);
    }
 
    void resize(size_type size, value_type val = value_type()) {
        auto old_size = this->size();
        check_code(Ns_::resize(&my_vector, size));
        if (old_size < size) {
            std::fill_n(begin() + old_size, size - old_size, val);
        }
    }
 
    void reserve(size_type capacity) {
        check_code(Ns_::reserve(&my_vector, capacity));
    }
 
    void shrink_to_fit() {
        Ns_::shrink_to_fit(&my_vector);
    }
 
    void push_back(value_type val) {
        check_code(Ns_::push_back(&my_vector, val));
    }
 
    template<typename ... Args>
    void emplace_back(Args&& ... args) {
        // Doesn't really matter for simple types.
        push_back(value_type(std::forward<Args>(args)...));
    }
 
    void pop_back() {
        Ns_::pop_back(&my_vector);
    }
 
    iterator erase(iterator pos) {
        Ns_::remove(&my_vector, pos - begin());
        return pos;
    }
 
    iterator erase(iterator first, iterator last) {
        auto start = begin();
        Ns_::remove_section(&my_vector, first - start, last - start);
        return first;
    }
 
    iterator insert(iterator pos, value_type val) {
        auto delta = pos - begin();
        check_code(Ns_::insert(&my_vector, delta, val));
        return begin() + delta; // recompute it as there might be a reallocation.
    }
 
    template<typename ... Args>
    iterator emplace(iterator pos, Args&& ... args) {
        // Doesn't really matter for simple types.
        return insert(pos, value_type(std::forward<Args>(args)...));
    }
 
    iterator insert(iterator pos, size_type n, value_type val) {
        auto delta = pos - begin();
        auto old_size = size();
        resize(old_size + n);
 
        auto new_start = begin() + delta; // recompute it as there might be a reallocation.
        std::copy(new_start, begin() + old_size, new_start + n);
        std::fill_n(new_start, n, val);
        return new_start; 
    }
 
    template<typename InputIterator, typename = decltype(*std::declval<InputIterator>())>
    iterator insert(iterator pos, InputIterator first, InputIterator last) {
        auto delta = pos - begin();
        auto old_size = size();
        auto n = last - first;
        resize(old_size + n);
 
        auto new_start = begin() + delta; // recompute it as there might be a reallocation.
        std::copy(new_start, begin() + old_size, new_start + n);
        std::copy(first, last, new_start);
        return new_start; 
    }
 
public:
    reference operator[](igraph_int_t i) {
        return *(begin() + i);
    }
 
    const_reference operator[](igraph_int_t i) const {
        return *(begin() + i);
    }
 
    reference back() {
        return *(end() - 1);
    }
 
    const_reference back() const {
        return *(end() - 1);
    }
 
    reference front() {
        return *(begin());
    }
 
    const_reference front() const {
        return *(begin());
    }
 
public:
    iterator begin() {
        return my_vector.stor_begin;
    }
 
    iterator end() {
        return my_vector.end;
    }
 
    const_iterator begin() const {
        return cbegin();
    }
 
    const_iterator end() const {
        return cend();
    }
 
    const_iterator cbegin() const {
        return my_vector.stor_begin;
    }
 
    const_iterator cend() const {
        return my_vector.end;
    }
 
    value_type* data() {
        return my_vector.stor_begin;
    }
 
    const value_type* data() const {
        return my_vector.stor_begin;
    }
 
    reverse_iterator rbegin() {
        return std::reverse_iterator(end());
    }
 
    reverse_iterator rend() {
        return std::reverse_iterator(begin());
    }
 
    reverse_const_iterator rbegin() const {
        return std::reverse_iterator(end());
    }
 
    reverse_const_iterator rend() const {
        return std::reverse_iterator(begin());
    }
 
    reverse_const_iterator crbegin() const {
        return std::reverse_iterator(cend());
    }
 
    reverse_const_iterator crend() const {
        return std::reverse_iterator(cbegin());
    }
 
public:
    operator igraph_type*() {
        return &my_vector;
    }
 
    operator const igraph_type*() const {
        return &my_vector;
    }
 
    igraph_type* get() {
        return &my_vector;
    }
 
    const igraph_type* get() const {
        return &my_vector;
    }
 
public:
    void swap(Vector<Ns_>& other)  {
        // Swapping structures entirely to ensure that iterators and pointers
        // remain valid; looks like igraph_vector_swap does the same.
        std::swap(my_vector, other.my_vector);
    }
 
private:
    igraph_type my_vector;
};
 
namespace internal {
 
struct Integer {
    typedef igraph_int_t value_type;
    typedef igraph_vector_int_t igraph_type;
 
#define RAIIGRAPH_VECTOR_SUFFIX _int
#include "fragments/vector.hpp"
#undef RAIIGRAPH_VECTOR_SUFFIX
};
 
struct Real {
    typedef igraph_real_t value_type;
    typedef igraph_vector_t igraph_type;
 
#define RAIIGRAPH_VECTOR_SUFFIX
#include "fragments/vector.hpp"
#undef RAIIGRAPH_VECTOR_SUFFIX
};
 
struct Bool {
    typedef igraph_bool_t value_type;
    typedef igraph_vector_bool_t igraph_type;
 
#define RAIIGRAPH_VECTOR_SUFFIX _bool
#include "fragments/vector.hpp"
#undef RAIIGRAPH_VECTOR_SUFFIX
};
 
}
typedef Vector<internal::Integer> IntVector;
 
// For back-compatibility.
typedef IntVector IntegerVector;
typedef Vector<internal::Real> RealVector;
 
typedef Vector<internal::Bool> BoolVector;
 
}
 
 
#endif