PrimoCell.hpp

Go to the documentation of this file.

 
#ifndef BASEPROJECT_Cell_HPP
#define BASEPROJECT_Cell_HPP
 
#include <cassert>
#include <mecacell/mecacell.h>
#include "../core/Model.hpp"
#include "../tools/TimeConvert.hpp"
#include "../tools/RandomManager.hpp"
 
/*isigen:eval@utilityDeclarations'''
    from string import Template
    from functools import cmp_to_key
    caseTemplate = Template("""
    case State::$name : {
    \t$code
    \tbreak;
    }""")
    def buildConditionsCode(destinations):
        destinations = sorted(destinations, key=cmp_to_key(lambda a, b: (a["condition"] == '')-(b["condition"] == '')))
        allCode = ''
        for i,d in enumerate(destinations):
            if d["to"] == 'CellInstantiation':
                action = 'this->init()'
            elif d["to"] == 'DeadCell':
                action = 'this->die()'
            else:
                action = 'this->state = State::{state}'.format(state=d["to"])
            if (i == 0) & (d["condition"] != ''): code = 'if({condition}) {action};\n'
            elif (i == 0) & (d["condition"] == ''): code = '{action};\n'
            elif d["condition"] == '': code = 'else {action};\n'
            else: code = 'else if({condition}) {action};\n'
            allCode += code.format(condition=d["condition"],action=action);
        return allCode;
    '''*/
 
/*isigen:insert@includes'''
    includes = ''
    for m,configJson in modulesConfigs.items():
        if "Body" in configJson:
            includes += '\n'.join(["#include \"../../{cellModulesPath}/{moduleName}/{cellInclude}\""\
                .format(cellModulesPath=cellModulesPath,moduleName=m,cellInclude=ci) for ci in configJson["Body"]["cellIncludes"] ])+'\n'
    print(includes)
    '''*/
 
using Vec = MecaCell::Vec;
using PreSetCell = Model::PreSetCell;
template<template<typename> class B>
class PrimoCell : public MecaCell::ConnectableCell<PrimoCell<B>, B> {
    using Base = MecaCell::ConnectableCell<PrimoCell<B>, B>;
public:
    using Cell = PrimoCell;
    using World = MecaCell::World<PrimoCell<B>>;
private:
    Model& model;
 
    Type type;
 
    State state;
 
    World& world; /* The world manages cell registration, IDs refresh, and plugins. */
 
    bool _alreadyNextState = false;
    bool _firstInit = true;
 
 
    void behave() {
        switch(this->state) {
            /*isigen:insert@behave'''
                behaviour = ''
                for s in builderData["cell"]["States"]:
                    behaviour += caseTemplate.substitute({'name':s['name'], 'code': s['code'].replace('\n','\n\t')})
                print(behaviour)
                '''*/
        default:
        {
            cout << "UNSPECIFIED CELL STATE : " << static_cast<unsigned int>(this->state) << endl;
            break;
            }
        }
    }
 
    void nextState() {
        switch(this->state){
            /*isigen:insert@nextState'''
                transition = ''
                for t in builderData["cell"]["Transitions"]:
                    transition += caseTemplate.substitute({'name': t['from'], 'code': buildConditionsCode(t['destinations']).replace('\n','\n\t')})
                print(transition)
                '''*/
        default:
        {
            //cout << "UNSPECIFIED CELL STATE : " << static_cast<unsigned int>(this->state) << endl;
            break;
            }
        }
    }
 
    Cell * createCell(){
        int idMother = this->id;
        auto *daughter = new PrimoCell(this);
        daughter->mother_id = idMother;
        this->mother_id = idMother;
        world.addCell(daughter);
        daughter->setType(this->type);
        daughter->init();
        return daughter;
    }
    
    Cell * createCell(Type t){
        int idMother = this->id;
        auto *daughter = new PrimoCell(this);
        daughter->mother_id = idMother;
        this->mother_id = idMother;
        world.addCell(daughter);
        daughter->setType(t);
        daughter->init();
        return daughter;
    }
 
public:
    int mother_id = -1;
 
    void setWorld(World* w) {
        assert(w == &world);
    }
    /*isigen:insert@attributes'''
        print('\n'.join(["\t{type} {value};".format(type=a['type'], value=a['value']) for a in builderData["cell"]["attributes"] if a['source'] != 'core']))
        '''*/
 
 
    /*isigen:insert@functions'''
        print('\n'.join([code.replace('\n','//isigen:metaDataDebug['+re.search(r'(\w+[\d_\w]+)\s*\‍(',code).group(1)+'] '+'{"idFunc":"'+idFunc+'"}\n',1) for idFunc,code in builderData["cell"]["functions"].items()]))
        '''*/
 
    
    /*isigen:insert@cellModuleFunctions'''
        print('\n'.join([ '\n'.join([c['code'] for c in v['cellFunctions']]) for v in modulesConfigs.values() if 'cellFunctions' in v]))
        '''*/
 
    PrimoCell(const MecaCell::Vec &v, Model &m, World &w)
    :Base(v), model(m), type((Type)0), world(w)
    {
        this->getBody().setPosition(v);
    }
 
    PrimoCell(Model &m, World &w)
    :Base(MecaCell::Vec(0.,0.,0.)), model(m), type((Type)0), world(w)
    {
        this->getBody().setPosition(MecaCell::Vec(0.,0.,0.));
    }
 
    PrimoCell(PrimoCell<B> *mother)
    :Base(mother->getBody().getPosition()), 
    model(mother->getModel()), type((Type)0), world(mother->world)
    {
        this->getBody().setPosition(mother->getBody().getPosition());
    }
 
    void init() {
        if(!_firstInit) world.refreshId(this);
        else _firstInit = false;
        model.initCell(this);
        /*isigen:insert@init'''
            initCode = builderData["cell"]["initializationCode"]
            if len(builderData["cell"]["initializationTransitions"])>0:
                destinations = builderData["cell"]["initializationTransitions"][0]["destinations"].copy()
                print(initCode+'\n'+buildConditionsCode(destinations))
            '''*/
        this->_alreadyNextState = true;
    }
 
    Model & getModel() const { return model; }
 
    Type getType() const { return type; }
 
    void setType(Type t) { type = t; model.initCell(this); }
 
    State getState() { return state; } 
 
    void setState(State s) { state = s; this->_alreadyNextState = true; } 
    
    double getRadius(){ return this->getBody().getBoundingBoxRadius(); }
 
    void setRadius(const double &_radius){ this->getBody().setRadius(_radius); }
 
    void setPosition(const MecaCell::Vec &_pos) { this->getBody().setPosition(_pos); }
 
    bool isType(Type t) {return this->type == t;}
 
    bool isInContactWith(Type t){ 
        for(auto *c : this->getConnectedCells())
            if(c->isType(t)) return true; 
        return false;
    }
 
    int countNeighborType(Type t){
        int count = 0;
        for(auto *c : this->getConnectedCells())
            if(c->isType(t)) count++;
        return count;
    }
 
    bool isInContact(){ return (this->getConnectedCells().size() > 0); }
 
    void updateBehavior(){
        this->_alreadyNextState = false;
        behave();
        if(!this->_alreadyNextState) nextState();
    }
 
    int getId() const { return this->id; }
 
    int getMotherId() const { return this->mother_id; }
 
 
    const PreSetCell& getParametersFrom(Type type) const {
        return this->model.getPreSetCell(type);
    }
};
 
 
#endif //BASEPROJECT_Cell_HPP
//'''