artis/src/artis/kernel/AbstractModel.hpp

/**
 * @file artis/kernel/AbstractModel.hpp
 * @author See the AUTHORS file
 */

/*
 * Copyright (C) 2012-2017 ULCO http://www.univ-littoral.fr
 *
 * 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/>.
 */

#ifndef __ARTIS_KERNEL_ABSTRACT_MODEL_HPP
#define __ARTIS_KERNEL_ABSTRACT_MODEL_HPP


#include <artis/kernel/Node.hpp>
#include <artis/context/State.hpp>
#include <artis/utils/DoubleTime.hpp>
#include <artis/utils/Trace.hpp>

#include <boost/core/demangle.hpp>

#include <typeinfo>
#if WIN32
#include <iso646.h>
#endif

namespace artis { namespace kernel {

template < typename Time, typename Parameters >
class AbstractModel : public Node < Time >
{
    typedef AbstractModel < Time, Parameters > type;

public:
    AbstractModel(const AbstractModel < Time, Parameters >* parent = 0) :
        parent(parent), last_time(-1)
    { }

    virtual ~AbstractModel()
    { }

    virtual void after(typename Time::type t) = 0;

    virtual const Node < Time >* atomic(unsigned int index) const = 0;

    virtual void before(typename Time::type t) = 0;

    virtual bool check(typename Time::type /* t */) const
    { return true; }

    virtual void compute(typename Time::type t, bool update) = 0;

    virtual void init(typename Time::type t, const Parameters& parameters) = 0;

    virtual bool is_atomic() const = 0;

    virtual bool is_computed(typename Time::type t) const
    { return last_time == t; }

    virtual bool is_stable(typename Time::type t) const = 0;

    virtual bool is_computed(typename Time::type t,
                             unsigned int index) const = 0;

    virtual bool is_updated() const = 0;

    virtual void operator()(typename Time::type t)
    {
        before(t);
        if (check(t) and (last_time != t or
                          (last_time == t and is_updated()))) {
#ifdef WITH_TRACE
            utils::Trace < utils::DoubleTime >::trace()
                << utils::TraceElement < utils::DoubleTime >(
                    true,
                    AbstractModel < Time, Parameters >::path(this),
                    t, utils::COMPUTE);
            utils::Trace < utils::DoubleTime >::trace().flush();
#endif
            compute(t, last_time == t);
            last_time = t;
            stable();
        }
        after(t);
    }

    virtual std::string path(
        const AbstractModel < Time, Parameters >* child) const
    {
        int index = -1;
        std::string p = type::parent ? type::parent->path_index(child, index) :
            "";

        if (index >= 0) {
            return p +
                "/[" + std::to_string(index) + "]" +
                boost::core::demangle(typeid(*child).name()); // .erase(0,6);
        } else {
            return (p.empty() ? "" : p + "/") +
                boost::core::demangle(typeid(*child).name()); // .erase(0,6);
        }
    }

    virtual std::string path_index(
        const AbstractModel < Time, Parameters >* child, int& index) const
    {
        (void) child;
        int i = -1;
        std::string p = type::parent ? type::parent->path_index(this, index) :
            "";

        index = -1;
        if (i >= 0) {
            return p +
                "/[" + std::to_string(i) + "]" +
                boost::core::demangle(typeid(*this).name());
        } else {
            return (p.empty() ? "" : p + "/") +
                boost::core::demangle(typeid(*this).name());
        }
    }

    virtual void restore(const context::State < Time >& state) = 0;

    virtual void save(context::State < Time >& state) const = 0;

    virtual void trace_element(typename Time::type t, utils::TraceType type,
                               std::string comment = "") const = 0;
    virtual void trace_internals(typename Time::type t,
                                 utils::TraceType type) const = 0;
    virtual void trace_externals(typename Time::type t,
                                 utils::TraceType type) const = 0;
    virtual void trace_model(typename Time::type t,
                             utils::TraceType type) const = 0;

    void set_parent(const AbstractModel < Time, Parameters >* p)
    { parent = p; }

    virtual void stable() = 0;

protected:
    const AbstractModel < Time, Parameters >* parent;
    typename Time::type                       last_time;
};

template < typename Time, typename Parameters >
using AbstractModels = std::vector < AbstractModel < Time, Parameters >* >;

} }

#endif