text: //===-- SBMemoryRegionInfoList.cpp ----------------------------------------===//
  //
  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  // See https://llvm.org/LICENSE.txt for license information.
  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  //
  //===----------------------------------------------------------------------===//
  
  #include "lldb/API/SBMemoryRegionInfoList.h"
  #include "lldb/Utility/ReproducerInstrumentation.h"
  #include "lldb/API/SBMemoryRegionInfo.h"
  #include "lldb/API/SBStream.h"
  #include "lldb/Target/MemoryRegionInfo.h"
  
  #include <vector>
  
  using namespace lldb;
  using namespace lldb_private;
  
  class MemoryRegionInfoListImpl {
  public:
    MemoryRegionInfoListImpl() : m_regions() {}
  
    MemoryRegionInfoListImpl(const MemoryRegionInfoListImpl &rhs)
        : m_regions(rhs.m_regions) {}
  
    MemoryRegionInfoListImpl &operator=(const MemoryRegionInfoListImpl &rhs) {
      if (this == &rhs)
        return *this;
      m_regions = rhs.m_regions;
      return *this;
    }
  
    size_t GetSize() const { return m_regions.size(); }
  
    void Reserve(size_t capacity) { return m_regions.reserve(capacity); }
  
    void Append(const MemoryRegionInfo &sb_region) {
      m_regions.push_back(sb_region);
    }
  
    void Append(const MemoryRegionInfoListImpl &list) {
      Reserve(GetSize() + list.GetSize());
  
      for (const auto &val : list.m_regions)
        Append(val);
    }
  
    void Clear() { m_regions.clear(); }
  
    bool GetMemoryRegionContainingAddress(lldb::addr_t addr,
                                          MemoryRegionInfo &region_info) {
      for (auto &region : m_regions) {
        if (region.GetRange().Contains(addr)) {
          region_info = region;
          return true;
        }
      }
      return false;
    }
  
    bool GetMemoryRegionInfoAtIndex(size_t index,
                                    MemoryRegionInfo &region_info) {
      if (index >= GetSize())
        return false;
      region_info = m_regions[index];
      return true;
    }
  
    MemoryRegionInfos &Ref() { return m_regions; }
  
    const MemoryRegionInfos &Ref() const { return m_regions; }
  
  private:
    MemoryRegionInfos m_regions;
  };
  
  MemoryRegionInfos &SBMemoryRegionInfoList::ref() { return m_opaque_up->Ref(); }
  
  const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
    return m_opaque_up->Ref();
  }
  
  SBMemoryRegionInfoList::SBMemoryRegionInfoList()
      : m_opaque_up(new MemoryRegionInfoListImpl()) {
    LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
  }
  
  SBMemoryRegionInfoList::SBMemoryRegionInfoList(
      const SBMemoryRegionInfoList &rhs)
      : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
    LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
                            (const lldb::SBMemoryRegionInfoList &), rhs);
  }
  
  SBMemoryRegionInfoList::~SBMemoryRegionInfoList() = default;
  
  const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
  operator=(const SBMemoryRegionInfoList &rhs) {
    LLDB_RECORD_METHOD(
        const lldb::SBMemoryRegionInfoList &,
        SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
        rhs);
  
    if (this != &rhs) {
      *m_opaque_up = *rhs.m_opaque_up;
    }
    return *this;
  }
  
  uint32_t SBMemoryRegionInfoList::GetSize() const {
    LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
  
    return m_opaque_up->GetSize();
  }
  
  bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
      lldb::addr_t addr, SBMemoryRegionInfo &region_info) {
    LLDB_RECORD_METHOD(
        bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
        (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);
  
    return m_opaque_up->GetMemoryRegionContainingAddress(addr, region_info.ref());
  }
  
  bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
      uint32_t idx, SBMemoryRegionInfo &region_info) {
    LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
                       (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
  
    return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
  }
  
  void SBMemoryRegionInfoList::Clear() {
    LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
  
    m_opaque_up->Clear();
  }
  
  void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
    LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
                       (lldb::SBMemoryRegionInfo &), sb_region);
  
    m_opaque_up->Append(sb_region.ref());
  }
  
  void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {
    LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
                       (lldb::SBMemoryRegionInfoList &), sb_region_list);
  
    m_opaque_up->Append(*sb_region_list);
  }
  
  const MemoryRegionInfoListImpl *SBMemoryRegionInfoList::operator->() const {
    return m_opaque_up.get();
  }
  
  const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const {
    assert(m_opaque_up.get());
    return *m_opaque_up;
  }
  