species_collection.h

#pragma once
 
#include <algorithm>
#include <cassert>
#include <memory>
#include <string>
#include <vector>
 
#include "base_species.h"
 
class SpeciesCollection {
 public:
  using Ptr = std::unique_ptr<BaseSpecies>;
 
  struct Entry {
    std::string key;
    Ptr species;
 
    // Forwarders mimic std::unique_ptr: const-on-Entry does NOT propagate to
    // the pointee, matching how `const std::unique_ptr<T>&` iteration behaved
    // under the previous std::map-backed storage.
    BaseSpecies* operator->() const {
      return species.get();
    }
    BaseSpecies& operator*() const {
      return *species;
    }
    BaseSpecies* get() const {
      return species.get();
    }
    explicit operator bool() const {
      return static_cast<bool>(species);
    }
  };
 
  using Container = std::vector<Entry>;
 
  SpeciesCollection()                                    = default;
  SpeciesCollection(const SpeciesCollection&)            = delete;
  SpeciesCollection& operator=(const SpeciesCollection&) = delete;
  SpeciesCollection(SpeciesCollection&&)                 = default;
  SpeciesCollection& operator=(SpeciesCollection&&)      = default;
 
  // ── Construction-phase mutation ─────────────────────────────────────────
  void insert(std::string key, Ptr species);
 
  void freeze();
 
  // ── Keyed lookup (replaces std::map API) ────────────────────────────────
  std::size_t count(const std::string& key) const;
 
  std::unique_ptr<BaseSpecies>& at(const std::string& key);
  const std::unique_ptr<BaseSpecies>& at(const std::string& key) const;
 
  std::unique_ptr<BaseSpecies>* find(const std::string& key);
  const std::unique_ptr<BaseSpecies>* find(const std::string& key) const;
 
  std::size_t index_of(const std::string& key) const {
    assert(frozen_);
    auto it = std::lower_bound(species_.begin(),
                               species_.end(),
                               key,
                               [](const Entry& e, const std::string& k) { return e.key < k; });
    if (it == species_.end() || it->key != key)
      return species_.size();
    return static_cast<std::size_t>(it - species_.begin());
  }
 
  // ── Hot-path cached accessors ───────────────────────────────────────────
  // Valid only after freeze(); asserted in debug builds.
  BaseSpecies& photons() {
    assert(frozen_ && photons_);
    return *photons_;
  }
  BaseSpecies& photons() const {
    assert(frozen_ && photons_);
    return *photons_;
  }
  BaseSpecies& baryons() {
    assert(frozen_ && baryons_);
    return *baryons_;
  }
  BaseSpecies& baryons() const {
    assert(frozen_ && baryons_);
    return *baryons_;
  }
  std::size_t photons_index() const {
    assert(frozen_);
    return photons_index_;
  }
  std::size_t baryons_index() const {
    assert(frozen_);
    return baryons_index_;
  }
  bool has_ncdm() const {
    assert(frozen_);
    return has_ncdm_;
  }
  bool has_warm_matter() const {
    assert(frozen_);
    return has_warm_matter_;
  }
 
  // ── Iteration / size ────────────────────────────────────────────────────
  Container::iterator begin() {
    return species_.begin();
  }
  Container::iterator end() {
    return species_.end();
  }
  Container::const_iterator begin() const {
    return species_.begin();
  }
  Container::const_iterator end() const {
    return species_.end();
  }
 
  bool empty() const {
    return species_.empty();
  }
  std::size_t size() const {
    return species_.size();
  }
 
  BaseSpecies* operator[](std::size_t i) {
    assert(i < species_.size());
    return species_[i].species.get();
  }
  const BaseSpecies* operator[](std::size_t i) const {
    assert(i < species_.size());
    return species_[i].species.get();
  }
 
 private:
  Container species_;
  BaseSpecies* photons_      = nullptr;
  BaseSpecies* baryons_      = nullptr;
  std::size_t photons_index_ = 0;
  std::size_t baryons_index_ = 0;
  bool has_ncdm_             = false;
  bool has_warm_matter_      = false;
  bool frozen_               = false;
};