network_mixins.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_MIXINS_HPP
#define CYPRESS_CORE_NETWORK_MIXINS_HPP

#include <algorithm>
#include <memory>
#include <iterator>

#include <cypress/core/connector.hpp>
#include <cypress/core/exceptions.hpp>
#include <cypress/core/network_base.hpp>
#include <cypress/core/neurons.hpp>
#include <cypress/core/types.hpp>
#include <cypress/util/comperator.hpp>

namespace cypress {
template <typename Impl, typename Accessor>
class PopulationMixin {
private:
    Impl &impl() { return reinterpret_cast<Impl &>(*this); }
    const Impl &impl() const { return reinterpret_cast<const Impl &>(*this); }

    NetworkBase network() const { return Accessor::network(impl()); }
    PopulationIndex pid() const { return Accessor::pid(impl()); }
    std::shared_ptr<PopulationData> data() const
    {
        return network().population_data(pid());
    }

public:
    const std::string &name() const { return data()->name(); }

    Impl &name(const std::string &name)
    {
        data()->name() = name;
        return impl();
    }

    size_t size() const { return data()->size(); }

    bool homogeneous_parameters() const
    {
        return data()->homogeneous_parameters();
    }

    bool homogeneous_record() const { return data()->homogeneous_record(); }

    bool homogeneous_data() const { return data()->homogeneous_data(); }
};

template <typename Impl>
class NeuronMixin {
private:
    Impl &impl() { return reinterpret_cast<Impl &>(*this); }
    const Impl &impl() const { return reinterpret_cast<const Impl &>(*this); }

public:
    Impl *operator->() { return &impl(); }
    const Impl *operator->() const { return &impl(); }
    Impl &operator*() { return impl(); }
    const Impl &operator*() const { return impl(); }
};

template <typename Impl, typename Accessor>
class ConnectableMixin {
private:
    Impl &impl() { return reinterpret_cast<Impl &>(*this); }
    const Impl &impl() const { return reinterpret_cast<const Impl &>(*this); }

    auto network() const { return Accessor::network(impl()); }
    PopulationIndex pid() const { return Accessor::pid(impl()); }
    NeuronIndex i0() const { return Accessor::begin(impl()); }
    NeuronIndex i1() const { return Accessor::end(impl()); }

public:
    template <typename TargetIterator>
    Impl &connect_to(TargetIterator tar_begin, TargetIterator tar_end,
                     std::unique_ptr<Connector> connector, const char *name = "")
    {
        network().connect(pid(), i0(), i1(), tar_begin->pid(), tar_begin->nid(),
                          tar_end->nid(), std::move(connector), name);
        return impl();
    }

    template <typename Target>
    Impl &connect_to(const Target &tar, std::unique_ptr<Connector> connector, const char *name = "")
    {
        return connect_to(tar.begin(), tar.end(), std::move(connector), name);
    }
};

template <typename Impl, typename Accessor, typename Params, typename Signals>
class DataMixin {
private:
    Impl &impl() { return reinterpret_cast<Impl &>(*this); }
    const Impl &impl() const { return reinterpret_cast<const Impl &>(*this); }

    auto network() const { return Accessor::network(impl()); }
    PopulationIndex pid() const { return Accessor::pid(impl()); }
    std::shared_ptr<PopulationData> data() const
    {
        return network().population_data(pid());
    }
    NeuronIndex i0() const { return Accessor::begin(impl()); }
    NeuronIndex i1() const { return Accessor::end(impl()); }

public:
    template <typename Other>
    bool operator==(const Other &o) const
    {
        return Comperator<int32_t>::equals(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    template <typename Other>
    bool operator!=(const Other &o) const
    {
        return Comperator<int32_t>::inequal(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    template <typename Other>
    bool operator<(const Other &o) const
    {
        return Comperator<int32_t>::smaller(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    template <typename Other>
    bool operator<=(const Other &o) const
    {
        return Comperator<int32_t>::smaller_equals(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    template <typename Other>
    bool operator>(const Other &o) const
    {
        return Comperator<int32_t>::larger(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    template <typename Other>
    bool operator>=(const Other &o) const
    {
        return Comperator<int32_t>::larger_equals(pid(), o.pid())(
            i0(), o.begin()->nid())(i1(), o.end()->nid())();
    }

    const NeuronType &type() const { return *(data()->type()); }

    const Params parameters() const { return Params(data(), i0(), i1()); }

    Params parameters() { return Params(data(), i0(), i1()); }

    const Signals signals() const { return Signals(data(), i0(), i1()); }

    Signals signals() { return Signals(data(), i0(), i1()); }
};

template <typename Impl, typename View, typename Accessor>
class ViewableMixin {
private:
    Impl &impl() { return reinterpret_cast<Impl &>(*this); }
    const Impl &impl() const { return reinterpret_cast<const Impl &>(*this); }

    auto network() const { return Accessor::network(impl()); }
    PopulationIndex pid() const { return Accessor::pid(impl()); }
    NeuronIndex i0() const { return Accessor::begin(impl()); }
    NeuronIndex i1() const { return Accessor::end(impl()); }

#ifndef NDEBUG

    void check_range(NeuronIndex nid0, NeuronIndex nid1) const
    {
        if (nid0 < i0() || nid1 > i1()) {
            throw std::out_of_range(
                "Range must be a subset of the source population range.");
        }
    }
#else
    void check_range(NeuronIndex, NeuronIndex) const {}
#endif

public:
    const View range(NeuronIndex begin, NeuronIndex end) const
    {
        check_range(i0() + begin, i0() + end);
        return View(network(), pid(), i0() + begin, i0() + end);
    }

    View range(NeuronIndex begin, NeuronIndex end)
    {
        check_range(i0() + begin, i0() + end);
        return View(network(), pid(), i0() + begin, i0() + end);
    }

    const View operator()(NeuronIndex begin, NeuronIndex end) const
    {
        return range(begin, end);
    }

    View operator()(NeuronIndex begin, NeuronIndex end)
    {
        return range(begin, end);
    }
};

template <typename Impl, typename Value, typename Accessor>
class IterableMixin {
public:
    template <int Dir, bool Const>
    class iterator_ : public std::iterator<std::random_access_iterator_tag,
                                           Value, NeuronIndex, Value, Value> {
    private:
        using Self = iterator_<Dir, Const>;

        using ImplPtr =
            typename std::conditional<Const, Impl const *, Impl *>::type;

        ImplPtr m_impl;

        NeuronIndex m_idx;

    public:
        iterator_(ImplPtr impl, NeuronIndex idx) : m_impl(impl), m_idx(idx) {}

        operator iterator_<Dir, true>() const
        {
            return iterator_<Dir, true>(m_impl, m_idx);
        }

        bool operator==(const Self &o) const { return m_idx == o.m_idx; }

        bool operator!=(const Self &o) const { return m_idx != o.m_idx; }

        bool operator<(const Self &o) const
        {
            return m_idx * Dir < o.m_idx * Dir;
        }

        bool operator>(const Self &o) const
        {
            return m_idx * Dir > o.m_idx * Dir;
        }

        bool operator<=(const Self &o) const
        {
            return m_idx * Dir <= o.m_idx * Dir;
        }

        bool operator>=(const Self &o) const
        {
            return m_idx * Dir >= o.m_idx * Dir;
        }

        Self operator+(NeuronIndex b) { return Self(m_impl, m_idx + b * Dir); }

        Self operator-(NeuronIndex b) { return Self(m_impl, m_idx - b * Dir); }

        NeuronIndex operator-(const Self &o) const
        {
            return (m_idx - o.m_idx) * Dir;
        }

        Self &operator++()
        {
            m_idx += Dir;
            return *this;
        }
        Self operator++(int)
        {
            auto cpy = Self(m_impl, m_idx);
            m_idx += Dir;
            return cpy;
        }

        Self &operator--()
        {
            m_idx -= Dir;
            return *this;
        }

        Self operator--(int)
        {
            auto cpy = Self(m_impl, m_idx);
            m_idx -= Dir;
            return cpy;
        }

        Self &operator+=(NeuronIndex n)
        {
            m_idx += n * Dir;
            return *this;
        }

        Self &operator-=(NeuronIndex n)
        {
            m_idx -= n * Dir;
            return *this;
        }

        template <typename U = Value,
                  typename = typename std::enable_if<!Const, U>::type>
        Value operator*()
        {
            return Value(*m_impl, m_idx);
        }

        template <typename U = Value,
                  typename = typename std::enable_if<!Const, U>::type>
        Value operator->()
        {
            return Value(*m_impl, m_idx);
        }

        template <typename U = Value,
                  typename = typename std::enable_if<!Const, U>::type>
        Value operator[](NeuronIndex n)
        {
            return Value(*m_impl, m_idx + n * Dir);
        }

        Value operator*() const { return Value(*m_impl, m_idx); }

        Value operator->() const { return Value(*m_impl, m_idx); }

        Value operator[](NeuronIndex n) const
        {
            return Value(*m_impl, m_idx + n * Dir);
        }
    };

private:
    Impl *impl() { return reinterpret_cast<Impl *>(this); }
    const Impl *impl() const { return reinterpret_cast<const Impl *>(this); }

    NeuronIndex i0() const { return Accessor::begin(*impl()); }
    NeuronIndex i1() const { return Accessor::end(*impl()); }
    NeuronIndex ri0() const { return Accessor::end(*impl()) - 1; }
    NeuronIndex ri1() const { return Accessor::begin(*impl()) - 1; }

#ifndef NDEBUG

    void check_range(NeuronIndex nid0, NeuronIndex nid1) const
    {
        if (nid0 < i0() || nid1 > i1()) {
            throw std::out_of_range(
                "Range must be a subset of the source population range.");
        }
    }
#else
    void check_range(NeuronIndex, NeuronIndex) const {}
#endif

public:
    using iterator = iterator_<1, false>;
    using const_iterator = iterator_<1, true>;
    using reverse_iterator = iterator_<-1, false>;
    using const_reverse_iterator = iterator_<-1, true>;

    Value operator[](NeuronIndex i) { return Value(*impl(), i0() + i); }

    const Value operator[](NeuronIndex i) const
    {
        return Value(*impl(), i0() + i);
    }

    Value operator()(NeuronIndex i) { return Value(*impl(), i0() + i); }

    const Value operator()(NeuronIndex i) const
    {
        return Value(*impl(), i0() + i);
    }

    size_t size() { return i1() - i0(); }

    iterator begin() { return iterator(impl(), i0()); }

    iterator end() { return iterator(impl(), i1()); }

    reverse_iterator rbegin() { return reverse_iterator(impl(), ri0()); }

    reverse_iterator rend() { return reverse_iterator(impl(), ri1()); }

    const_iterator begin() const { return cbegin(); }

    const_iterator end() const { return cend(); }

    const_reverse_iterator rbegin() const { return crbegin(); }

    const_reverse_iterator rend() const { return crend(); }

    const_iterator cbegin() const { return const_iterator(impl(), i0()); }

    const_iterator cend() const { return const_iterator(impl(), i1()); }

    const_reverse_iterator crbegin() const
    {
        return const_reverse_iterator(impl(), ri0());
    }

    const_reverse_iterator crend() const
    {
        return const_reverse_iterator(impl(), ri1());
    }
};
}

#endif /* CYPRESS_CORE_NETWORK_MIXINS_HPP */