array_ref.hh

Go to the documentation of this file.

/*
    @@@@@@@@  @@           @@@@@@   @@@@@@@@ @@
   /@@/////  /@@          @@////@@ @@////// /@@
   /@@       /@@  @@@@@  @@    // /@@       /@@
   /@@@@@@@  /@@ @@///@@/@@       /@@@@@@@@@/@@
   /@@////   /@@/@@@@@@@/@@       ////////@@/@@
   /@@       /@@/@@//// //@@    @@       /@@/@@
   /@@       @@@//@@@@@@ //@@@@@@  @@@@@@@@ /@@
   //       ///  //////   //////  ////////  //

   Copyright (c) 2016, Triad National Security, LLC
   All rights reserved.
                                                                              */
#pragma once

#include <array>
#include <assert.h>
#include <cstddef>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>

namespace flecsi {
namespace util {

template<typename T>
class array_ref
{

public:
  typedef T value_type;
  typedef const T * pointer;
  typedef const T & reference;
  typedef const T & const_reference;
  typedef const T * const_iterator;
  typedef const_iterator iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef const_reverse_iterator reverse_iterator;
  typedef std::size_t size_type;
  typedef ptrdiff_t difference_type;


  constexpr array_ref() : ptr_(nullptr), length_(0) {}
  constexpr array_ref(const array_ref &) = default;
  array_ref & operator=(const array_ref &) = default;

  constexpr array_ref(const T * array, const size_type length)
    : ptr_(array), length_(length) {}

  // Implicit conversion constructors

  template<typename Allocator>
  array_ref(const std::vector<T, Allocator> & v)
    : ptr_(v.data()), length_(v.size()) {}

  template<typename traits, typename Allocator>
  array_ref(const std::basic_string<T, traits, Allocator> & s)
    : ptr_(s.data()), length_(s.size()) {}

  template<size_type N>
  constexpr array_ref(const T (&a)[N]) : ptr_(a), length_(N) {}

  template<size_type N>
  constexpr array_ref(const std::array<T, N> & a)
    : ptr_(a.data()), length_(N) {}

  constexpr array_ref substr(const size_type pos,
    const size_type n = size_type(-1)) const {
    // Recursive implementation to satisfy constexpr.
    return (pos > size() ? substr(size(), n)
                         : n > size() - pos ? substr(pos, size() - pos)
                                            : array_ref(data() + pos, n));
  }

  constexpr const_iterator begin() const {
    return ptr_;
  }
  constexpr const_iterator end() const {
    return ptr_ + length_;
  }
  constexpr const_iterator cbegin() const {
    return begin();
  }
  constexpr const_iterator cend() const {
    return end();
  }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(end());
  }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(begin());
  }
  const_reverse_iterator crbegin() const {
    return rbegin();
  }
  const_reverse_iterator crend() const {
    return rend();
  }

  constexpr size_type size() const {
    return length_;
  }
  constexpr size_type max_size() const {
    return (std::numeric_limits<size_type>::max)() / sizeof(T);
  }
  constexpr bool empty() const {
    return length_ == 0;
  }

  constexpr const T & operator[](const size_type i) const {
    return ptr_[i];
  }
  constexpr const T & at(const size_type i) const {
    // This makes at() constexpr as long as the argument is within the
    // bounds of the array_ref.
    /*
    // However, possibly returning a throw, as in the following construction,
    // gives "warning: returning reference to temporary [-Wreturn-local-addr]"
    return i >= size() ? throw std::out_of_range("at() argument out of range")
      : ptr_[i];
    */
    if(i >= size())
      throw std::out_of_range("at() argument out of range");
    return ptr_[i];
  }

  constexpr const T & front() const {
    return ptr_[0];
  }
  constexpr const T & back() const {
    return ptr_[length_ - 1];
  }

  constexpr const T * data() const {
    return ptr_;
  }


  explicit operator std::vector<T>() const {
    return std::vector<T>(begin(), end());
  }
  std::vector<T> vec() const {
    return std::vector<T>(*this);
  }

  template<typename traits, typename Allocator>
  explicit operator std::basic_string<T, traits, Allocator>() const {
    return std::basic_string<T, traits, Allocator>(begin(), end());
  }
  std::basic_string<T> str() const {
    return std::basic_string<T>(*this);
  }



  void clear() {
    *this = array_ref();
  }

  void remove_prefix(const size_type n) {
    assert(length_ >= n);
    ptr_ += n;
    length_ -= n;
  }

  void remove_suffix(const size_type n) {
    assert(length_ >= n);
    length_ -= n;
  }
  void pop_back() {
    remove_suffix(1);
  }
  void pop_front() {
    remove_prefix(1);
  }

private:
  const T * ptr_;
  size_type length_;
};


template<typename T>
constexpr array_ref<T>
make_array_ref(const T * array, const std::size_t length) {
  return array_ref<T>(array, length);
}

template<typename T, std::size_t N>
constexpr array_ref<T>
make_array_ref(const T (&a)[N]) {
  return array_ref<T>(a);
}

template<typename T>
array_ref<T>
make_array_ref(const std::vector<T> & v) {
  return array_ref<T>(v);
}

template<typename T, std::size_t N>
array_ref<T>
make_array_ref(const std::array<T, N> & a) {
  return array_ref<T>(a);
}


} // namespace util
} // namespace flecsi