artis/src/test/test2.cpp

/**
 * @file test/test2.cpp
 * @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/>.
 */

//#define CATCH_CONFIG_MAIN
//#include <test/catch.hpp>

#include <test/models.hpp>

#include <artis/kernel/Simulator.hpp>
#include <artis/observer/Output.hpp>

#include <artis/utils/DateTime.hpp>

using namespace artis::kernel;

/*
typedef Builder <
    CoupledModel <
        Type < RootModel >,
        Name < >,
        ID < >,
        States < >,
        Internals < >,
        Externals < >,
        Submodels <
            AtomicModel <
                Type < AModel >,
                Name < RootModel::_a >,
                ID < A >,
                States < >,
                Internals <
                    Variable < Name < AModel::_ix >,
                               ID < IX >,
                               Type < int >
                               >,
                    Variable < Name < AModel::_bx >,
                               ID < BX >,
                               Type < bool >
                               >,
                    Variable < Name < AModel::_dx >,
                               ID < DX >,
                               Type < double >
                               >
                    >,
                Externals < >,
                >,
            AtomicModel <
                Type < BModel >,
                Name < RootModel::_b >,
                ID < B >,
                States < >,
                Internals < >,
                Externals < >,
                >
            >
        >
    > ABuilder;
*/

template < class M >
class mpBuilder
{
public:
    mpBuilder(const std::map < int, int> m)
    { }
};

template < class T, class I, class S, class In >
class mpAtomicModel
{
};

template < class M >
class mpType
{
};

template < class M >
class mpName
{
};

template < int N >
class mpID
{
};

template < class... M >
class mpStates
{
};

template < class... M >
class mpInternals
{
};

template < class I, class T >
class mpVariable
{
};

typedef mpBuilder <
    mpAtomicModel <
        mpType < AModel >,
        mpID < RootModel::A >,
        mpStates < >,
        mpInternals <
            mpVariable < mpID < AModel::IX >,
                         mpType < int >
                         >,
            mpVariable < mpID < AModel::BX >,
                         mpType < bool >
                         >,
            mpVariable < mpID < AModel::DX >,
                         mpType < double >
                         >
            >
        >
    > ABuilder;

int main()
{
    GlobalParameters globalParameters;
    ModelParameters modelParameters;
    ABuilder builder({{AModel::IX,1},{AModel::BX,1},{AModel::DX,1}});

    return 0;
}