OpenTTCN/Developer corner/Implementing external functions/Final/CPP/PA impl.cpp

From OpenTTCN

OpenTTCN DocZone   Home | Developer's corner | Knowledge base | Working documents | Documentation | OpenTTCN IDE | Tutorials | Training | How do I | Frequently asked questions | Technical support

PA_impl.cpp

---

Back to main article >>

#include "PA_impl.h"

#include <StartHere.h>

using OpenTTCN::SDK::StartHere;

#include <iostream>

PA_impl::ExtFuncMapType PA_impl :: _extFuncMap;

bool PA_impl :: _extFuncMapInitialized = false;

/***************************************************************************
 * Initialization of TRI interface (PA, user-provided part).
 */

PA_impl :: PA_impl()
{
    if (!_extFuncMapInitialized)
    {
        _extFuncMap["ef_calc_sum"] = &PA_impl::ef_calc_sum;
        _extFuncMap["ef_calc_sub"] = &PA_impl::ef_calc_sub;
        _extFuncMap["ef_calc_mul"] = &PA_impl::ef_calc_mul;
        _extFuncMap["ef_calc_div"] = &PA_impl::ef_calc_div;
        _extFuncMap["ef_find_and_replace"] = &PA_impl::ef_find_and_replace;

        _extFuncMapInitialized = true;
    }
}

PA_impl :: ~PA_impl()
{
}

/***************************************************************************
 * Implementation of TRI interface (PA, user-provided part).
 */

TriStatus PA_impl :: triPAReset()
{
    return TRI_OK;
}

TriStatus PA_impl :: triStartTimer(
    const TriTimerId *timerId,
    const TriTimerDuration *timerDuration)
{
    return TRI_ERROR;
}

TriStatus PA_impl :: triStopTimer(
    const TriTimerId *timerId)
{
    return TRI_ERROR;
}

TriStatus PA_impl :: triReadTimer(
    const TriTimerId *timerId,
    TriTimerDuration *elapsedTime)
{
    return TRI_ERROR;
}

TriStatus PA_impl :: triTimerRunning(
    const TriTimerId *timerId,
    Tboolean &running)
{
    return TRI_ERROR;
}

TriStatus PA_impl :: triExternalFunction(
    const TriFunctionId *functionId,
    TriParameterList *parameterList,
    TriParameter *returnValue)
{
    std::string funcId = functionId->getObjectName();

    std::cout << "**************************************************************************" << std::endl;
    std::cout << "*** DEBUG: triExternalFunction() callback called. Function: " << funcId << std::endl;

    ExtFuncMapType::iterator iter = _extFuncMap.find(funcId);

    if (iter != _extFuncMap.end())
    {
        return (*(iter->second))(functionId, parameterList, returnValue);
    }

    std::string errMsg = "Unrecognized external function " + funcId + " called.";
    StartHere::reportError(errMsg);

    return TRI_ERROR;
}

/***************************************************************************
 * External function implementation helpers.
 */

static long triParameterToLong(TriParameter* src)
{
    return *((const long *) src->getEncodedParameter());
}

static void assignLongToTriParameter(TriParameter* dst, long src)
{
    int len = sizeof(long);

    unsigned char* dst_par_data = (unsigned char *) malloc(len);
    memcpy(dst_par_data, &src, len);
    long dst_par_bits = len << 3;

    dst->setEncodedParameter(dst_par_data, dst_par_bits);

    free(dst_par_data);
}

static std::string triParameterToString(TriParameter* src)
{
    const unsigned char* src_par_data = src->getEncodedParameter();

    long str_len =
        (((unsigned long) src_par_data[0]) << 8) |
        (((unsigned long) src_par_data[1]) << 0);

    return std::string((const char *) (src_par_data + 2), str_len);
}

static void assignStringToTriParameter(TriParameter* dst, const std::string& src)
{
    long str_len = (long) src.size();

    unsigned char* dst_par_data = (unsigned char *) malloc(str_len + 2);
    long dst_par_bits = (str_len + 2) << 3;

    // String length, most significant byte first:

    dst_par_data[0] = (unsigned char) (str_len >> 8);
    dst_par_data[1] = (unsigned char) (str_len >> 0);

    // String data:

    memcpy(dst_par_data + 2, src.c_str(), str_len);

    dst->setEncodedParameter(dst_par_data, dst_par_bits);

    free(dst_par_data);
}

/***************************************************************************
 * External function implementations.
 */

TriStatus PA_impl :: ef_calc_sum(
    const TriFunctionId *functionId,
    TriParameterList *parameterList,
    TriParameter *returnValue)
{
    TriParameterList* pars = parameterList;

    assignLongToTriParameter(returnValue,
        triParameterToLong(&pars->get(0)) + triParameterToLong(&pars->get(1)));

    return TRI_OK;
}

TriStatus PA_impl :: ef_calc_sub(
    const TriFunctionId *functionId,
    TriParameterList *parameterList,
    TriParameter *returnValue)
{
    TriParameterList* pars = parameterList;

    assignLongToTriParameter(returnValue,
        triParameterToLong(&pars->get(0)) - triParameterToLong(&pars->get(1)));

    return TRI_OK;
}

TriStatus PA_impl :: ef_calc_mul(
    const TriFunctionId *functionId,
    TriParameterList *parameterList,
    TriParameter *returnValue)
{
    TriParameterList* pars = parameterList;

    assignLongToTriParameter(returnValue,
        triParameterToLong(&pars->get(0)) * triParameterToLong(&pars->get(1)));

    return TRI_OK;
}

TriStatus PA_impl :: ef_calc_div(
    const TriFunctionId *functionId,
    TriParameterList *parameterList,
    TriParameter *returnValue)
{
    TriParameterList* pars = parameterList;

    assignLongToTriParameter(returnValue,
        triParameterToLong(&pars->get(0)) / triParameterToLong(&pars->get(1)));

    return TRI_OK;
}

static void ef_find_and_replace_helper(
    std::string& str /* inout */,
    const std::string& search_substr /* in */,
    const std::string& new_substr /* in */,
    long& occurences_num /* out */)
{
    int i, len;
    int substr_size = (int) search_substr.size();

    if (substr_size != new_substr.size())
    {
        StartHere::reportError("Strings size mismatch in ef_find_and_replace().");
        return;
    }

    if (!substr_size)
    {
        StartHere::reportError("Search string size is zero in ef_find_and_replace().");
        return;
    }

    occurences_num = 0;
    if (substr_size > (int) str.size())
    {
        // No way bigger string can be a substring of the smaller one:
        return; 
    }

    len = ((int) str.size()) - substr_size;
    for (i = 0; i <= len; i++)
    {
        if (str.substr(i, substr_size) == search_substr)
        {
            str.replace(i, substr_size, new_substr);
            occurences_num++;
            i += substr_size - 1;
        }
    }
}

TriStatus PA_impl :: ef_find_and_replace(const TriFunctionId* functionId,
    TriParameterList* parameterList, TriParameter* returnValue)
{
    TriParameterList* pars = parameterList;

    std::string str = triParameterToString(&pars->get(0));
    std::string search_substr = triParameterToString(&pars->get(1));
    std::string new_substr = triParameterToString(&pars->get(2));
    long occurences_num = -1;

    ef_find_and_replace_helper(
        str, search_substr, new_substr, occurences_num);

    // It is safe to assume that inout str always changes:

    assignStringToTriParameter(&pars->get(0), str);

    // Perform mandatory assignment of occurences_num out parameter:

    assignLongToTriParameter(&pars->get(3), occurences_num);

    // Duplicate occurences_num in the return value:

    assignLongToTriParameter(returnValue, occurences_num);

    return TRI_OK;
}