Subversion Repositories public iLand

/********************************************************************************************

**    iLand - an individual based forest landscape and disturbance model

**    http://iland.boku.ac.at

**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl

**

**    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/>.

********************************************************************************************/

#include "global.h"

#include "abe_global.h"

#include "fmstp.h"

#include "fmstand.h"

#include "fomescript.h"

#include "fomewrapper.h"

#include "expression.h"

namespace ABE {

/** @class FMSTP

    @ingroup abe

    The FMSTP class encapsulates a stand treatment program, which is defined in Javascript.

  */

// static values

bool FMSTP::mVerbose = false;

FMSTP::FMSTP()

{

    mSalvage = 0;

    mRotationLength[0] = 90.; // sensible defaults

    mRotationLength[1] = 100.;

    mRotationLength[2] = 110.;

    mOptions=QJSValue(0);

}

FMSTP::~FMSTP()

{

    clear();

}

Activity *FMSTP::activity(const QString &name) const

{

    int idx = mActivityNames.indexOf(name);

    if (idx==-1)

        return 0;

    return mActivities[idx];

}

bool activityScheduledEarlier(const Activity *a, const Activity *b)

{

    return a->earlistSchedule() < b->earlistSchedule();

}

void FMSTP::setup(QJSValue &js_value, const QString name)

{

    clear();

    if(!name.isEmpty())

        mName = name;

    // (1) scan recursively the data structure and create

    //     all activites

    internalSetup(js_value, 0);

    // (2) create all other required meta information (such as ActivityStand)

    // sort activites based on the minimum execution time

    std::sort(mActivities.begin(), mActivities.end(), activityScheduledEarlier);

    mActivityNames.clear();

    mHasRepeatingActivities = false;

    for (int i=0;i<mActivities.count();++i) {

        mActivityNames.push_back(mActivities.at(i)->name());

        mActivityStand.push_back(mActivities.at(i)->standFlags()); // stand = null: create a copy of the activities' base flags

        mActivities.at(i)->setIndex(i);

        if (mActivities.at(i)->isRepeatingActivity())

            mHasRepeatingActivities = true;

        if (mActivities.at(i)->standFlags().isSalvage()) {

            mSalvage = dynamic_cast<ActSalvage*>(mActivities.at(i));

            mHasRepeatingActivities = false;

        }

    }

    // (3) set up top-level events

    mEvents.setup(js_value, QStringList() << QStringLiteral("onInit") << QStringLiteral("onExit"));

}

bool FMSTP::executeRepeatingActivities(FMStand *stand)

{

    if (mSalvage)

        if (stand->totalHarvest() || stand->property("_run_salvage").toBool()) {

        // at this point totalHarvest is only disturbance related harvests.

        stand->executeActivity(mSalvage);

    }

    if (!mHasRepeatingActivities)

        return false;

    bool result = false;

    for (int i=0;i<mActivities.count();++i)

        if (mActivities.at(i)->schedule().repeat) {

            if (!stand->flags(i).active() || !stand->flags(i).enabled())

                continue;

            if (stand->trace())

                qCDebug(abe) << "running repeating activity" << mActivities.at(i)->name();

            result |= stand->executeActivity(mActivities[i]);

        }

    return result; // return true if at least one repeating activity was executed.

}

void FMSTP::evaluateDynamicExpressions(FMStand *stand)

{

    foreach(Activity *act, mActivities)

        act->evaluateDyanamicExpressions(stand);

}

// read the setting from the setup-javascript object

void FMSTP::internalSetup(const QJSValue &js_value, int level)

{

    // top-level

    if (js_value.hasOwnProperty("schedule")) {

        setupActivity(js_value, "unnamed");

        return;

    }

    // nested objects

    if (js_value.isObject()) {

        QJSValueIterator it(js_value);

        while (it.hasNext()) {

            it.next();

            // parse special properties

            if (it.name()=="U" && it.value().isArray()) {

                QVariantList list = it.value().toVariant().toList();

                if (list.length()!=3)

                    throw IException("STP: the 'U'-property needs to be an array with three elements!");

                for (int i=0;i<list.length();++i)

                    mRotationLength[i] = list.at(i).toInt();

                continue;

            }

            if (it.name()=="options") {

                mOptions = it.value();

                continue;

            }

            if (it.value().hasOwnProperty("type")) {

                // try to set up as activity

                setupActivity(it.value(), it.name());

            } else if (it.value().isObject() && !it.value().isCallable()) {

                // try to go one level deeper

                if (FMSTP::verbose())

                    qCDebug(abeSetup) << "entering" << it.name();

                if (level<10)

                    internalSetup(it.value(), ++level);

                else

                    throw IException("setup of STP: too many nested levels (>=10) - check your syntax!");

            }

        }

    } else {

        qCDebug(abeSetup) << "FMSTP::setup: not a valid javascript object.";

    }

}

void FMSTP::dumpInfo()

{

    if (!abe().isDebugEnabled())

        return;

    qCDebug(abe) << " ***************************************";

    qCDebug(abe) << " **************** Program dump for:" << name();

    qCDebug(abe) << " ***************************************";

    foreach(Activity *act, mActivities) {

        qCDebug(abe) << "******* Activity *********";

        QString info =  act->info().join('\n');

        qCDebug(abe) << info;

    }

}

void FMSTP::setupActivity(const QJSValue &js_value, const QString &name)

{

    QString type = js_value.property("type").toString();

    if (verbose())

        qCDebug(abeSetup) << "setting up activity of type" << type << "from JS";

    Activity *act = Activity::createActivity(type, this);

    if (!act) return; // actually, an error is thrown in the previous call.

    // use id-property if available, or the object-name otherwise

    act->setName(valueFromJs(js_value, "id", name).toString());

    // call the setup routine (overloaded version)

    act->setup(js_value);

    // call the onCreate handler:

    FomeScript::bridge()->setActivity(act);

    act->events().run(QStringLiteral("onCreate"),0);

    mActivities.push_back(act);

}

void FMSTP::clear()

{

    qDeleteAll(mActivities);

    mActivities.clear();

    mEvents.clear();

    mActivityStand.clear();

    mActivityNames.clear();

    mSalvage = 0;

    mOptions=QJSValue(0); // clear

    mName.clear();

}

QJSValue FMSTP::valueFromJs(const QJSValue &js_value, const QString &key, const QString default_value, const QString &errorMessage)

{

   if (!js_value.hasOwnProperty(key)) {

       if (!errorMessage.isEmpty())

           throw IException(QString("Error: required key '%1' not found. In: %2 (JS: %3)").arg(key).arg(errorMessage).arg(FomeScript::JStoString(js_value)));

       else if (default_value.isEmpty())

           return QJSValue();

       else

           return default_value;

   }

   return js_value.property(key);

}

bool FMSTP::boolValueFromJs(const QJSValue &js_value, const QString &key, const bool default_bool_value, const QString &errorMessage)

{

    if (!js_value.hasOwnProperty(key)) {

        if (!errorMessage.isEmpty())

            throw IException(QString("Error: required key '%1' not found. In: %2 (JS: %3)").arg(key).arg(errorMessage).arg(FomeScript::JStoString(js_value)));

        else

            return default_bool_value;

    }

    return js_value.property(key).toBool();

}

bool FMSTP::checkObjectProperties(const QJSValue &js_value, const QStringList &allowed_properties, const QString &errorMessage)

{

    QJSValueIterator it(js_value);

    bool found_issues = false;

    while (it.hasNext()) {

        it.next();

        if (!allowed_properties.contains(it.name()) && it.name()!=QLatin1String("length")) {

            qCDebug(abe) << "Syntax-warning: The javascript property" << it.name() << "is not used! In:" << errorMessage;

            found_issues = true;

        }

    }

    return !found_issues;

}

} // namespace