network_base_objects.hpp

Go to the documentation of this file.

/*
 *  Cypress -- C++ Spiking Neural Network Simulation Framework
 *  Copyright (C) 2016  Andreas Stöckel
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef CYPRESS_CORE_NETWORK_BASE_OBJECTS_HPP
#define CYPRESS_CORE_NETWORK_BASE_OBJECTS_HPP

#include <cypress/core/network_base.hpp>
#include <cypress/core/network_mixins.hpp>

namespace cypress {

/*
 * Forward declarations
 */
class PopulationBase;
class PopulationViewBase;
class NeuronBase;
struct Accessor;

class PopulationBase
    : public PopulationMixin<PopulationBase, Accessor>,
      public IterableMixin<PopulationBase, NeuronBase, Accessor>,
      public ViewableMixin<PopulationBase, PopulationViewBase, Accessor>,
      public DataMixin<PopulationBase, Accessor, NeuronParameters,
                       NeuronSignals>,

      public ConnectableMixin<PopulationBase, Accessor> {
private:
    NetworkBase m_network;
    PopulationIndex m_pid;

public:
    using PopulationMixin::size;
    using IterableMixin::operator();
    using ViewableMixin::operator();

    PopulationBase(const NetworkBase &network, PopulationIndex pid)
        : m_network(network), m_pid(pid)
    {
    }

    NetworkBase network() const { return m_network; }

    PopulationIndex pid() const { return m_pid; }
};

class PopulationViewBase
    : public IterableMixin<PopulationViewBase, NeuronBase, Accessor>,
      public ViewableMixin<PopulationViewBase, PopulationViewBase, Accessor>,
      public DataMixin<PopulationViewBase, Accessor, NeuronParameters,
                       NeuronSignals>,
      public ConnectableMixin<PopulationViewBase, Accessor> {
private:
    NetworkBase m_network;
    PopulationIndex m_pid;
    NeuronIndex m_nid0;
    NeuronIndex m_nid1;

public:
    using IterableMixin::operator();
    using ViewableMixin::operator();

    PopulationViewBase(const NetworkBase &network, PopulationIndex pid,
                       NeuronIndex nid0, NeuronIndex nid1)
        : m_network(network), m_pid(pid), m_nid0(nid0), m_nid1(nid1)
    {
    }

    NetworkBase network() const { return m_network; }

    PopulationIndex pid() const { return m_pid; }

    NeuronIndex nid_begin() const { return m_nid0; }

    NeuronIndex nid_end() const { return m_nid1; }
};

class NeuronBase
    : public NeuronMixin<NeuronBase>,
      public IterableMixin<NeuronBase, NeuronBase, Accessor>,
      public ViewableMixin<NeuronBase, PopulationViewBase, Accessor>,
      public DataMixin<NeuronBase, Accessor, NeuronParameters,
                       NeuronSignals>,
      public ConnectableMixin<NeuronBase, Accessor> {
private:
    NetworkBase m_network;
    PopulationIndex m_pid;
    NeuronIndex m_nid;

public:
    using IterableMixin::operator();
    using ViewableMixin::operator();

    template <typename Parent>
    NeuronBase(const Parent &parent, NeuronIndex nid)
        : m_network(parent.network()), m_pid(parent.pid()), m_nid(nid)
    {
    }

    const NeuronType &type() const { return m_network[m_pid].type(); }

    NetworkBase network() const { return NetworkBase(m_network); }

    PopulationBase population() const
    {
        return PopulationBase(m_network, m_pid);
    }

    PopulationIndex pid() const { return m_pid; }

    NeuronIndex nid() const { return m_nid; }
};

struct Accessor {
    static NeuronIndex begin(const PopulationBase &) { return 0; }
    static NeuronIndex end(const PopulationBase &pop) { return pop.size(); }
    static PopulationIndex pid(const PopulationBase &pop) { return pop.pid(); }
    static NetworkBase network(const PopulationBase &pop)
    {
        return pop.network();
    }

    static NeuronIndex begin(const PopulationViewBase &view)
    {
        return view.nid_begin();
    }
    static NeuronIndex end(const PopulationViewBase &view)
    {
        return view.nid_end();
    }
    static PopulationIndex pid(const PopulationViewBase &view)
    {
        return view.pid();
    }
    static NetworkBase network(const PopulationViewBase &view)
    {
        return view.network();
    }

    static NeuronIndex begin(const NeuronBase &neuron) { return neuron.nid(); }
    static NeuronIndex end(const NeuronBase &neuron)
    {
        return neuron.nid() + 1;
    }
    static PopulationIndex pid(const NeuronBase &neuron)
    {
        return neuron.pid();
    }
    static NetworkBase network(const NeuronBase &neuron)
    {
        return neuron.network();
    }
};
}

#endif /* CYPRESS_CORE_NETWORK_BASE_OBJECTS_HPP */