population.h

Go to the documentation of this file.

 
#pragma once
 
#include <knp/core/core.h>
#include <knp/core/messaging/synaptic_impact_message.h>
#include <knp/core/uid.h>
#include <knp/neuron-traits/all_traits.h>
 
#include <functional>
#include <utility>
#include <vector>
 
namespace knp::core
{
 
template <typename NeuronType>
class Population final
{
public:
    using PopulationNeuronType = NeuronType;
    using PopulationType = Population<NeuronType>;
    using NeuronParameters = neuron_traits::neuron_parameters<NeuronType>;
 
    using NeuronGenerator = std::function<std::optional<NeuronParameters>(size_t index)>;
 
public:  // NOLINT
    Population(NeuronGenerator generator, size_t neurons_count);
 
    Population(const knp::core::UID &uid, NeuronGenerator generator, size_t neurons_count);
 
public:  // NOLINT
    [[nodiscard]] const UID &get_uid() const { return base_.uid_; }
 
    [[nodiscard]] auto &get_tags() { return base_.tags_; }
 
    [[nodiscard]] const auto &get_tags() const { return base_.tags_; }
 
public:  // NOLINT
    [[nodiscard]] const std::vector<NeuronParameters> &get_neurons_parameters() const { return neurons_; }
 
    [[nodiscard]] const NeuronParameters &get_neuron_parameters(size_t index) const { return neurons_[index]; }
 
    void set_neuron_parameters(size_t index, NeuronParameters &&parameters) { neurons_[index] = std::move(parameters); }
 
    void set_neurons_parameters(size_t index, const NeuronParameters &parameters) { neurons_[index] = parameters; }
 
public:  // NOLINT
    [[nodiscard]] TagMap &get_neuron_tags(size_t index)
    {
        return base_.tags_.template get_tag<std::vector<TagMap>>("neuron_tags")[index];
    }
 
public:  // NOLINT
    void add_neurons(NeuronGenerator generator, size_t count)
    {
        neurons_.reserve(count);
        for (size_t i = 0; i < count; ++i)
        {
            auto neuron = generator(i);
            if (neuron.has_value())
            {
#if defined(_MSC_VER)
                neurons_.emplace_back(std::move(neuron.value()));
#else
                neurons_.template emplace_back(std::move(neuron.value()));
#endif
            }
        }
    }
 
    void remove_neurons(const std::vector<size_t> &neuron_indexes)
    {
        size_t index_shift = 0;
        for (const auto &index : neuron_indexes)
        {
            remove_neuron(index - index_shift++);
        }
    }
 
    void remove_neuron(const size_t &neuron_index)
    {
        auto iter = neurons_.begin();
        std::advance(iter, neuron_index);
        neurons_.erase(iter);
    }
 
public:  // NOLINT
    const auto &operator[](size_t index) const { return get_neuron_parameters(index); }
    auto &operator[](size_t index) { return neurons_[index]; }
 
    auto begin() const { return neurons_.cbegin(); }
    auto begin() { return neurons_.begin(); }
    auto end() const { return neurons_.cend(); }
    auto end() { return neurons_.end(); }
 
public:  // NOLINT
    [[nodiscard]] size_t size() const { return neurons_.size(); }
 
private:
    BaseData base_;
    std::vector<NeuronParameters> neurons_;
};
 
 
using AllPopulations = boost::mp11::mp_transform<knp::core::Population, knp::neuron_traits::AllNeurons>;
 
using AllPopulationsVariant = boost::mp11::mp_rename<AllPopulations, std::variant>;
 
}  // namespace knp::core