Range_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_TYPES_RANGE_FWD_HPP_
#define MEDUSA_BITS_TYPES_RANGE_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/utils/assert.hpp>
#include "traits.hpp"
#include <memory>
#include <vector>
#include <iosfwd>
 
namespace mm {
 
template<class T, class Allocator = std::allocator<T>>
class Range : public std::vector<T, Allocator> {
  public:
    typedef typename std::vector<T, Allocator>::value_type value_type;
    typedef typename std::vector<T, Allocator>::reference reference;
    typedef typename std::vector<T, Allocator>::const_reference const_reference;
    typedef int size_type;
 
    class RangeView {
        Range<T>& receiver;  
        const indexes_t& modifier;  
 
        RangeView(Range<T>& receiver_, const indexes_t& modifier_)
                : receiver(receiver_), modifier(modifier_) {}
 
      public:
        RangeView(RangeView&) = delete;  
        RangeView(RangeView&&) = delete;  
        RangeView& operator=(RangeView&) = delete;  
        RangeView& operator=(RangeView&&) = delete;  
 
        Range<T> asRange() const {
            Range<T> ret(size());
            int sz = modifier.size();
            for (int i = 0; i < sz; ++i) ret[i] = operator[](i);
            return ret;
        }
 
        void operator=(const Range<T>& rhs) {
            assert_msg(rhs.size() == size(),
                       "Container sizes must match in multiindexed assignment, but my size is %d "
                       "and assigned size is %d.", size(), rhs.size());
            for (size_type i = 0; i < size(); ++i) operator[](i) = rhs[i];
        }
 
        void operator=(const value_type& x) {
            for (size_type i = 0; i < size(); ++i)
                operator[](i) = x;
        }
 
        reference operator[](size_type i) { return receiver[modifier[i]]; }
 
        const_reference operator[](size_type i) const { return receiver[modifier[i]]; }
 
        size_type size() const { return static_cast<int>(modifier.size()); }
 
        friend class Range;
 
        friend std::ostream& operator<<(std::ostream& os, const RangeView& c) {
            return os << c.asRange();
        }
    };
 
    class ConstRangeView {
        const Range<T>& receiver;  
        const indexes_t& modifier;  
 
        ConstRangeView(const Range<T>& receiver_, const indexes_t& modifier_)
                : receiver(receiver_), modifier(modifier_) {}
 
      public:
        ConstRangeView(ConstRangeView&) = delete;  
        ConstRangeView(ConstRangeView&&) = delete;  
        ConstRangeView& operator=(ConstRangeView&) = delete;  
        ConstRangeView& operator=(ConstRangeView&&) = delete;  
 
        Range<T> asRange() const {
            Range<T> ret(size());
            int sz = modifier.size();
            for (int i = 0; i < sz; ++i) ret[i] = operator[](i);
            return ret;
        }
 
        const_reference operator[](size_type i) const { return receiver[modifier[i]]; }
 
        size_type size() const { return static_cast<int>(modifier.size()); }
 
        friend class Range;
 
        friend std::ostream& operator<<(std::ostream& os, const ConstRangeView& c) {
            return os << c.asRange();
        }
    };
 
  public:
    using std::vector<T, Allocator>::vector;
    using std::vector<T, Allocator>::operator=;
    Range(const Range& o) = default;  
    Range() : std::vector<T, Allocator>() {}  
    Range(Range&& o) noexcept = default;  
    Range& operator=(const Range& o) = default;  
    Range& operator=(Range&& o) noexcept = default;  
    Range(const std::vector<T, Allocator>& o) : std::vector<T, Allocator>(o) {}
    Range(std::vector<T, Allocator>&& o) noexcept : std::vector<T, Allocator>(std::move(o)) {}
    Range(const Range::RangeView& o) : Range(o.asRange()) {}
    Range(const Range::ConstRangeView& o) : Range(o.asRange()) {}
 
    template <typename V>
    static Range seq(V n);
    template <typename V>
    static Range seq(V start, V stop);
    template <typename V, typename D>
    static Range seq(V start, V stop, D step);
 
    Range& operator=(std::initializer_list<value_type> lst);
 
    Range& operator=(const value_type& x);
 
    reference operator[](size_type i);
 
    const_reference operator[](size_type i) const;
 
    RangeView operator[](const indexes_t& indexes);
 
    ConstRangeView operator[](const indexes_t& indexes) const;
 
    int size() const { return static_cast<int>(std::vector<T, Allocator>::size()); }
 
    Range& append(const Range& rng);
    Range& operator+=(const Range& rng) { return append(rng); }
 
    Range join(const Range& rng) const;
 
    void remove(indexes_t indexes);
 
    template<class Predicate>
    indexes_t filter(const Predicate& predicate) const;
 
    template<typename UnaryOp>
    auto map(UnaryOp op) -> Range<decltype(op(this->operator[](0)))> const;
 
    indexes_t operator<(const value_type& v) const;
 
    indexes_t operator>(const value_type& v) const;
 
    indexes_t operator<=(const value_type& v) const;
 
    indexes_t operator>=(const value_type& v) const;
 
    indexes_t operator==(const value_type& v) const;
 
    indexes_t operator!=(const value_type& v) const;
};
 
template <typename T> struct scalar_type<Range<T>> {
    typedef typename Range<T>::value_type type;  
};
template <typename T> struct vector_type<Range<T>> {
    typedef typename Range<T>::value_type type;  
};
template <typename T> struct scalar_type<std::vector<T>> {
    typedef typename std::vector<T>::value_type type;  
};
template <typename T> struct vector_type<std::vector<T>> {
    typedef typename std::vector<T>::value_type type;  
};
 
template<class T, class Allocator = std::allocator<T>>
std::vector<T, Allocator> operator+(const std::vector<T, Allocator>& v1,
                                    const std::vector<T, Allocator>& v2) {
    std::vector<T, Allocator> ret = v1;
    ret.insert(ret.end(), v2.begin(), v2.end());
    return ret;
}
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_TYPES_RANGE_FWD_HPP_