/var/www/hormigaproject.com.ar/files/src/step/step.cpp

Go to the documentation of this file.

/*
# Hormiga - Software de cálculo programable.
#
# Copyright (C) 2008, 2009 Leonardo Román, Hugo J. Curti, Norma  Ercoli,
# Universidad Nacional del Centro de la Provincia de Buenos Aires
# (UNCPBA)
#
# Este programa es parte de Hormiga.
#
# Hormiga es software libre. Puede redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Pública General de GNU según es
# publicada por la Free Software Foundation, versión 2. Vea el archivo
# COPIA (español, no oficial) o COPYING (inglés, oficial) en directorio
# raíz.
#
# Hormiga se distribuye con la esperanza de que sea útil, pero SIN
# NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin
# garantizar la CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Véase la
# Licencia Pública General de GNU para más detalles.
#
# Debería haber recibido una copia de la Licencia Pública General junto
# con Hormiga. Si no ha sido así, escriba a la Free Software
# Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.
# Añada también información sobre cómo contactar con usted mediante
# correo electrónico y postal.
#
# This file is part of Hormiga.
#
# Hormiga is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation; see the file COPYING
# in the top directory for details.
#
# Hormiga 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 Hormiga; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
# USA
*/

#include "step.h"
#include "stdio.h"
#include <QMetaType>
Step::Step( T_STRING name )
{
    this->name = name ;
    this->execBlock = NULL ;
    this->stepsNeeded = NULL ;
    this->captures = NULL ;
    this->reports = NULL ;
    this->condition = NULL ;
    unsatisfiedDependencesCount = 0 ;
    this->currentState = Step::Satisfied ;
    this->alreadyExecuted = false ;

    if ( QMetaType::type("Step") == 0 )
    {   /* We need to register our types used in signals */
        qRegisterMetaType<Step*>("Step") ;
        qRegisterMetaType<Step::state>("Step::state") ;
    }
}

Step::~Step()
{
    if ( this->stepsNeeded != NULL ) delete this->stepsNeeded ;
    if ( this->captures != NULL ) delete this->captures ;
    if ( this->reports != NULL ) delete this->reports ;
    if ( this->execBlock != NULL ) delete this->execBlock ;
    if ( this->condition != NULL ) delete this->condition ;
}


T_STRING Step::toString () const
{
    return ( this->name ) ;
}

T_STRING Step::getName ()
{
    return ( this->name ) ;
}

void Step::run ()
{
    this->exec( true ) ;
}

bool Step::exec ( bool interactive )
{
    if ( this->currentState == Step::NotSatisfied )
        return ( false ) ;
    this->changeState( Step::Executing ) ;
    this->alreadyExecuted = true ;
    if ( this->captures != NULL && interactive )
    {
        /* We will wait here for user input (if any GUI is connected for) */
        emit needInput ( this , this->captures ) ;
        /* If the GUI is not "bloking" on connected slot then will need to sleep
           the Step thread
           */
    }

    execSleep.lock() ;
    bool result = this->execBlock->exec() ;
    execSleep.unlock() ;

    if ( this->reports != NULL && interactive )
        emit reportOutput( this, this->reports ) ;

    /* Are conditions OK ? */
    if ( this->condition != NULL && ! this->condition->eval() )
    {
        result = FALSE ;
        this->showMessage( 2, this->condition->getText() ) ;
    }
    /* Wait for GUI to show the reports, if is any */
    execSleep.lock() ;
    // Se cumplen las condiciones ?
    if ( result )
    {
        this->changeState( Step::Accepted ) ;
    } else {
        this->changeState( Step::Satisfied ) ;
    }
    execSleep.unlock() ;
    return ( true ) ;
}

void Step::setStepNeeds ( T_STEP_LIST *stepsNeeded )
{
    if ( stepsNeeded == NULL )
        return ;
    this->stepsNeeded = stepsNeeded ;
    for ( int i = 0 ; i < stepsNeeded->count() ; i++ )
    {
        QObject::connect ( stepsNeeded->at( i ) , SIGNAL (
                             stateChanged(Step*,Step::state,Step::state) ) ,
                           this , SLOT (
                             notifyStepState( Step*, Step::state,Step::state) )
                         ) ;
    }

    this->unsatisfiedDependencesCount = stepsNeeded->count() ;
    // By now... this is the unique option:
    this->changeState( Step::NotSatisfied ) ;
}

void Step::setExecutionBlock ( Statement *execBlock )
{
    this->execBlock = execBlock ;
}

void Step::setCaptures ( T_CAPTURE_LIST *clist )
{
    this->captures = clist ;
}

void Step::setReports ( T_REPORT_LIST *reports )
{
    this->reports = reports ;
}

void Step::setStepCondition ( StepCondition *condition )
{
    this->condition = condition ;
}

void Step::changeState ( Step::state newState )
{
    if ( this->currentState != newState )
    {
        Step::state oldState = this->currentState ;
        this->currentState = newState ;
        emit stateChanged( this , newState , oldState ) ;
    }
}

/* Slots */
void Step::notifyStepState( Step* peer , Step::state newState ,
                            Step::state oldState )
{
    /* - de <cualquier_estado> a [aceptado] : counter--
     * - de [aceptado] a  <cualquier_estado> : counter ++
     * Deberiamos verificar que 'peer' sea uno de los de la lista de
     * dependencias ? Por ahora "confiaremos" en que si.
     */
    if ( ( newState == Step::Accepted ) || ( oldState == Step::Accepted ) )
        printf("Step %s notified. Step %s state changed from %d to %d\n",
           this->getName().toAscii().data(),
           peer->getName().toAscii().data(), oldState, newState );
    if ( newState == Step::Accepted )
    {
        this->unsatisfiedDependencesCount-- ;
        if ( this->unsatisfiedDependencesCount == 0 )
        {
            this->changeState( Step::Satisfied ) ;
            // We should re-run this step ? -> this->start() ;
            if ( this->alreadyExecuted )
                this->exec( false ) ; // Re-run me serialized ;)
        }
    }
    else if ( oldState == Step::Accepted )
    {
        this->unsatisfiedDependencesCount++ ;
        this->changeState( Step::NotSatisfied ) ;
    }
}


StepConditionSingle::StepConditionSingle ( Operand *condition , T_STRING text )
{
    this->condition = condition ;
    this->text = text ;
}

StepConditionSingle::~StepConditionSingle()
{
    if ( this->condition != NULL ) delete this->condition ;
}

bool StepConditionSingle::eval()
{
    if ( this->condition == NULL ) return TRUE ;
    return ( ( this->condition->getValue() != FALSE )? TRUE : FALSE ) ;
}

T_STRING StepConditionSingle::getText()
{
    return this->text ;
}



StepConditionComposite::StepConditionComposite ( T_STEP_CONDITIONS_LIST* list )
{
    this->list = list ;
    this->last = NULL ;
}

StepConditionComposite::~StepConditionComposite ()
{
    for ( int i = 0 ; i < list->count() ; i++ )
        delete list->takeFirst() ;
    delete this->list ;
}

bool StepConditionComposite::eval()
{
    for ( int i = 0 ; i < list->count() ; i++ )
    {
        this->last = this->list->at( i ) ;
        if ( ! this->last->eval() )
            return FALSE ;
    }
    return TRUE ;
}

T_STRING StepConditionComposite::getText()
{
    if ( this->last != NULL )
        return this->last->getText() ;
    return "" ;
}