BLI_index_range.hh

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <iostream>
 
#include "BLI_utildefines.h"
 
namespace blender {
 
template<typename T> class Span;
 
class IndexRange {
 private:
  int64_t start_ = 0;
  int64_t size_ = 0;
 
 public:
  constexpr IndexRange() = default;
 
  constexpr explicit IndexRange(int64_t size) : start_(0), size_(size)
  {
    BLI_assert(size >= 0);
  }
 
  constexpr IndexRange(int64_t start, int64_t size) : start_(start), size_(size)
  {
    BLI_assert(start >= 0);
    BLI_assert(size >= 0);
  }
 
  class Iterator {
   public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = int64_t;
    using pointer = const int64_t *;
    using reference = const int64_t &;
    using difference_type = std::ptrdiff_t;
 
   private:
    int64_t current_;
 
   public:
    constexpr explicit Iterator(int64_t current) : current_(current)
    {
    }
 
    constexpr Iterator &operator++()
    {
      current_++;
      return *this;
    }
 
    constexpr Iterator operator++(int) const
    {
      Iterator copied_iterator = *this;
      ++copied_iterator;
      return copied_iterator;
    }
 
    constexpr friend bool operator!=(const Iterator &a, const Iterator &b)
    {
      return a.current_ != b.current_;
    }
 
    constexpr friend bool operator==(const Iterator &a, const Iterator &b)
    {
      return a.current_ == b.current_;
    }
 
    constexpr int64_t operator*() const
    {
      return current_;
    }
  };
 
  constexpr Iterator begin() const
  {
    return Iterator(start_);
  }
 
  constexpr Iterator end() const
  {
    return Iterator(start_ + size_);
  }
 
  constexpr int64_t operator[](int64_t index) const
  {
    BLI_assert(index >= 0);
    BLI_assert(index < this->size());
    return start_ + index;
  }
 
  constexpr friend bool operator==(IndexRange a, IndexRange b)
  {
    return (a.size_ == b.size_) && (a.start_ == b.start_ || a.size_ == 0);
  }
 
  constexpr int64_t size() const
  {
    return size_;
  }
 
  constexpr IndexRange after(int64_t n) const
  {
    BLI_assert(n >= 0);
    return IndexRange(start_ + size_, n);
  }
 
  constexpr IndexRange before(int64_t n) const
  {
    BLI_assert(n >= 0);
    return IndexRange(start_ - n, n);
  }
 
  constexpr int64_t first() const
  {
    BLI_assert(this->size() > 0);
    return start_;
  }
 
  constexpr int64_t last() const
  {
    BLI_assert(this->size() > 0);
    return start_ + size_ - 1;
  }
 
  constexpr int64_t one_after_last() const
  {
    return start_ + size_;
  }
 
  constexpr int64_t start() const
  {
    return start_;
  }
 
  constexpr bool contains(int64_t value) const
  {
    return value >= start_ && value < start_ + size_;
  }
 
  constexpr IndexRange slice(int64_t start, int64_t size) const
  {
    BLI_assert(start >= 0);
    BLI_assert(size >= 0);
    int64_t new_start = start_ + start;
    BLI_assert(new_start + size <= start_ + size_ || size == 0);
    return IndexRange(new_start, size);
  }
  constexpr IndexRange slice(IndexRange range) const
  {
    return this->slice(range.start(), range.size());
  }
 
  Span<int64_t> as_span() const;
 
  friend std::ostream &operator<<(std::ostream &stream, IndexRange range)
  {
    stream << "[" << range.start() << ", " << range.one_after_last() << ")";
    return stream;
  }
};
 
}  // namespace blender