Sim.cpp

#include "Headers.h"
#include "Sim.h"
#include "Console.h"

CSim::CSim(char* name, CSimModel* model)
{
    assert(name);
    assert(model);
    this->name = name;
    this->model = model;

    // Set the handler to the model
    this->model->Init(this);

    // Create the event list
    this->events = new CSimEventList(this->model);

    // Create the calls list
    this->calls = new CSimCalls();
}

CSim::~CSim()
{
    delete this->events;
    delete this->calls;
}

__uint32 CSim::Run(time_t& duration)
{
    this->time = 0;
    
    __uint32 oldPercent = 1;
    __uint32 newPercent;
    __time div = 100000;
    time_t startTime;
    time_t currentTime;
    time_t endTime;

    ::time(&startTime);

    printf("\n%s : Start simulation (max time = %lf)\n", this->name, this->model->MaxTime());

    while((this->events->HasEvents()) && (time <= this->model->MaxTime()))
    {
        newPercent = (__uint32)(100*time/this->model->MaxTime());
        if(newPercent != oldPercent)
        {
            ::time(&currentTime);

            endTime = startTime + (time_t)(time?((currentTime-startTime)*this->model->MaxTime()/time):(currentTime-startTime));

#if !defined(_RELEASEASSERT) && !defined(_RELEASELOG) && !defined(_DEBUG) && !defined(LOG)
            printf("%s : %u percent complete (time is %.3lf of %.lf, %ld seconds passed, %ld seconds remaining)\t\t", this->name, newPercent, time, this->model->MaxTime(), currentTime-startTime, endTime - currentTime);
            CConsole::MoveCursorBeginLine();
            printf("\n");
#endif
            oldPercent = newPercent;
        }

        // Execute current event
        CSimEvent* evt = this->events->GetEvent(time);
        assert(evt);

        this->model->Run(evt);

        delete evt;

        // Execute current calls
        this->calls->Execute();
    }

    // Finalize model
    this->model->Finalize();

    // Clean all events
    this->events->Clean();

    // Clean all calls
    this->calls->Clean();

    ::time(&endTime);

    duration = endTime - startTime;

    return this->events->Size();
}

__time CSim::Time()
{
    return this->time;
}

void CSim::ScheduleEventNow(CSimEvent* evt)
{
    assert(evt);
    this->events->Add(this->time, evt);
}

void CSim::ScheduleEventAt(__time time, CSimEvent* evt)
{
    assert(evt);
    assert(time >= this->time);
    this->events->Add(time, evt);
}

void CSim::ScheduleEventAfter(__time delay, CSimEvent* evt)
{
    assert(evt);
    assert(this->time + delay >= this->time);
    this->events->Add(this->time + delay, evt);
}

void CSim::CancelEvent(__time time, CSimEvent* evt)
{
    assert(evt);
    if(time < this->time) return;   // If event is in the past, do nothing

    this->events->Cancel(time, evt);
    delete evt;
}

void CSim::operator()(ICall* call)
{
    assert(call);
    // Add call to the calls list
    this->calls->Add(call);
}