iterable.h

// Copyright 2024 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include "pw_allocator/block/contiguous.h"
 
namespace pw::allocator {
namespace internal {
 
// Trivial base class for trait support.
struct IterableBase {};
 
}  // namespace internal
 
 
template <typename Derived>
class IterableBlock : public internal::IterableBase {
 protected:
  constexpr explicit IterableBlock() {
    static_assert(is_contiguous_v<Derived>,
                  "Types derived from IterableBlock must also derive "
                  "from ContiguousBlock");
  }
 
 public:
  class Iterator final {
   public:
    constexpr explicit Iterator(Derived* block) : block_(block) {}
    constexpr Iterator& operator++();
    constexpr bool operator!=(const Iterator& other);
    constexpr Derived* operator*() { return block_; }
 
   private:
    Derived* block_;
  };
 
  class Range final {
   public:
    constexpr explicit Range(Derived* begin) : begin_(begin), end_(nullptr) {}
 
    constexpr Range(Derived* begin_inclusive, Derived* end_inclusive)
        : begin_(begin_inclusive), end_(end_inclusive->Next()) {}
 
    constexpr Iterator& begin() { return begin_; }
    constexpr Iterator& end() { return end_; }
 
   private:
    Iterator begin_;
    Iterator end_;
  };
};
 
template <typename BlockType>
struct is_iterable : std::is_base_of<internal::IterableBase, BlockType> {};
 
template <typename BlockType>
constexpr bool is_iterable_v = is_iterable<BlockType>::value;
 
 
// Template method implementations.
 
template <typename Derived>
constexpr auto IterableBlock<Derived>::Iterator::operator++() -> Iterator& {
  block_ = block_ != nullptr ? block_->Next() : nullptr;
  return *this;
}
 
template <typename Derived>
constexpr bool IterableBlock<Derived>::Iterator::operator!=(
    const Iterator& other) {
  return block_ != other.block_;
}
 
}  // namespace pw::allocator