population.h

Go to the documentation of this file.

#pragma once
#include "person.h"
 
#ifndef NDEBUG
#include <cassert>
#endif
 
#include <vector>
 
namespace hgps {
 
class Population {
  public:
    using IteratorType = std::vector<Person>::iterator;
    using ConstIteratorType = std::vector<Person>::const_iterator;
 
    Population() = delete;
    explicit Population(const std::size_t size);
 
    std::size_t size() const noexcept;
 
    std::size_t initial_size() const noexcept;
 
    std::size_t current_active_size() const noexcept;
 
    Person &operator[](std::size_t index);
 
    const Person &operator[](std::size_t index) const;
 
    Person &at(std::size_t index);
 
    const Person &at(std::size_t index) const;
 
    void add(Person person, unsigned int time) noexcept;
 
    void add_newborn_babies(std::size_t number, core::Gender gender, unsigned int time) noexcept;
 
    IteratorType begin() noexcept { return people_.begin(); }
 
    IteratorType end() noexcept { return people_.end(); }
 
    ConstIteratorType begin() const noexcept { return people_.cbegin(); }
 
    ConstIteratorType end() const noexcept { return people_.cend(); }
 
    ConstIteratorType cbegin() const noexcept { return people_.cbegin(); }
 
    ConstIteratorType cend() const noexcept { return people_.cend(); }
 
  private:
    std::size_t initial_size_;
    // MAHIMA: Lifetime-unique person ID counter for post-initial entrants.
    // Initial cohort keeps deterministic IDs [1..initial_size_] for baseline/intervention
    // alignment. All later entrants (births/immigration) get IDs from this monotonic counter and
    // IDs are never reused even when slots are recycled.
    std::size_t next_person_id_{1};
    std::vector<Person> people_;
 
    std::vector<int> find_index_of_recyclables(unsigned int time,
                                               std::size_t top = 0) const noexcept;
 
    std::size_t allocate_next_person_id() noexcept {
        const std::size_t id = next_person_id_;
#ifndef NDEBUG
        // MAHIMA: Debug-only duplicate-ID guard; compiled out in release (no extra memory or work).
        assert(id != Person::unassigned_id);
        assert(id == next_person_id_ && "Person ID must be the next unused value (no reuse)");
#endif
        ++next_person_id_;
        return id;
    }
};
} // namespace hgps