apiGRDPUtils.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * Pointwise Plugin utility functions
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#include <string.h>
 
#include "apiPWP.h"
#include "apiGRDPUtils.h"
#include "apiGridModel.h"
#include "pwpPlatform.h"
 
 
GRDP_RTITEM*
grdpFindFormatById (PWP_UINT32 id)
{
    GRDP_RTITEM *ret = 0;
    PWP_UINT32 ii;
    for (ii=0; ii < grdpFormatCnt; ++ii) {
        if (id == grdpRtItem[ii].FormatInfo.id) {
            ret = &(grdpRtItem[ii]);
            break;
        }
    }
    return ret;
}
 
 
GRDP_RTITEM*
grdpFindFormatByName (const char name[])
{
    GRDP_RTITEM *ret = 0;
    PWP_UINT32 ii;
    for (ii=0; ii < grdpFormatCnt; ++ii) {
        if (0 == strcmp(grdpRtItem[ii].FormatInfo.name, name)) {
            ret = &(grdpRtItem[ii]);
            break;
        }
    }
    return ret;
}
 
 
PWP_BOOL
grdpProgressInit(GRDP_RTITEM *pRti, PWP_UINT32 cnt)
{
    PWP_BOOL ret = PWP_FALSE;
    if (pRti) {
        pRti->progTotal = 0;
        pRti->progComplete  = 0;
        pRti->clocks[GRDP_CLKS_PROGUPDATE] =
            pRti->clocks[GRDP_CLKS_PROGINIT] = clock();
        pRti->opAborted = PWP_FALSE;
        ret = PwuProgressBegin(pRti->pApiData->apiInfo.name, cnt);
        pRti->opAborted |= !ret;
    }
    return ret;
}
 
 
PWP_BOOL
grdpProgressBeginStep(GRDP_RTITEM *pRti, PWP_UINT32 total)
{
    PWP_BOOL ret = PWP_FALSE;
    if (pRti && (total > 0)) {
        pRti->progComplete = 0;
        pRti->progTotal = total;
        ret = !pRti->opAborted;
        pRti->clocks[GRDP_CLKS_BEGSTEP] = clock();
    }
    return ret;
}
 
 
PWP_BOOL
grdpProgressIncr(GRDP_RTITEM *pRti)
{
    PWP_BOOL ret = PWP_FALSE;
    if (pRti && !pRti->opAborted) {
        // send update a max of 2 times per second
        const clock_t DELAY = (CLOCKS_PER_SEC / 2);
        pRti->clocks[GRDP_CLKS_PROGINCR] = clock();
        ++pRti->progComplete;
        if (DELAY <= GRDP_RT_CLKS_DIFF(pRti, GRDP_CLKS_PROGUPDATE,
                        GRDP_CLKS_PROGINCR)) {
            ret = PwuProgressStatus (pRti->pApiData->apiInfo.name,
                pRti->progComplete, pRti->progTotal);
            pRti->clocks[GRDP_CLKS_PROGUPDATE] =
                pRti->clocks[GRDP_CLKS_PROGINCR];
            pRti->opAborted |= !ret;
        }
        else {
            ret = PWP_TRUE;
        }
    }
    return ret;
}
 
/*------------------------------------*/
static void
sendDiffTimeMsg(GRDP_RTITEM *pRti, const char txt[], clock_t diff)
{
    if (pRti) {
        PWP_INT32 hours;
        PWP_INT32 minutes;
        PWP_INT32 seconds;
        char msg[512];
        char *p = msg;
        if (txt && txt[0]) {
            strcpy(p, txt);
            strcat(p, ": ");
            p += strlen(p);
        }
        GRDP_CLKS_TO_HMS(diff, hours, minutes, seconds);
        sprintf(p, "%ld:%02ld:%02ld (h:mm:ss) / %ld msec", (long)hours,
            (long)minutes, (long)seconds, (long)GRDP_CLKS_TO_MSECS(diff));
        grdpSendDebugMsg(pRti, msg, 0);
    }
}
 
/*------------------------------------*/
static void
sendClkDiffTimeMsg(GRDP_RTITEM *pRti, const char txt[],
    GRDP_ENUM_CLOCKS startId, GRDP_ENUM_CLOCKS endId)
{
    if (pRti) {
        sendDiffTimeMsg(pRti, txt,
            GRDP_RT_CLKS_DIFF(pRti, startId, endId));
    }
}
 
 
PWP_BOOL
grdpProgressEndStep(GRDP_RTITEM *pRti)
{
    PWP_BOOL ret = PWP_FALSE;
    if (pRti) {
        pRti->clocks[GRDP_CLKS_ENDSTEP] = clock();
        pRti->progComplete = 0;
        pRti->progTotal = 0;
        ret = PwuProgressNextStep(pRti->pApiData->apiInfo.name);
        pRti->opAborted |= !ret;
        sendClkDiffTimeMsg(pRti, "Step time", GRDP_CLKS_BEGSTEP,
            GRDP_CLKS_ENDSTEP);
    }
    return ret;
}
 
 
PWP_BOOL
grdpProgressEnd(GRDP_RTITEM *pRti, const PWP_BOOL ok)
{
    if (pRti) {
        pRti->clocks[GRDP_CLKS_PROGEND] = clock();
        pRti->progTotal = 0;
        pRti->progComplete  = 0;
        pRti->clocks[GRDP_CLKS_PROGUPDATE] = 0;
        PwuProgressEnd(pRti->pApiData->apiInfo.name, ok);
        sendClkDiffTimeMsg(pRti, "Export time", GRDP_CLKS_PROGINIT,
            GRDP_CLKS_PROGEND);
    }
    return ok;
}
 
 
void
grdpSendDebugMsg(GRDP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendDebugMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
grdpSendInfoMsg(GRDP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendInfoMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
grdpSendWarningMsg(GRDP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendWarningMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
grdpSendErrorMsg(GRDP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendErrorMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
 
PWP_BOOL
grdpPublishValueDefinition(const char name[], PWP_ENUM_VALTYPE type, const char value[],
    const char access[], const char desc[], const char range[])
{
    PWP_BOOL ret = PWP_FALSE;
    ret = PwuPublishValueDefinition(GRDP_VALUE_GROUP, name, type, value, access, desc,
            range);
    return ret;
}
 
 
PWP_BOOL
grdpAssignInfoValue(const char name[], const char value[], const bool create)
{
    return PwuAssignValue(GRDP_INFO_GROUP, name, value, create);
}
 
 
PWP_BOOL
grdpAssignInfoValueInt(const char name[], const PWP_INT value, const bool create)
{
    return PwuAssignValueInt(GRDP_INFO_GROUP, name, value, create);
}
 
 
PWP_BOOL
grdpAssignInfoValueUInt(const char name[], const PWP_UINT value, const bool create)
{
    return PwuAssignValueUInt(GRDP_INFO_GROUP, name, value, create);
}
 
 
PWP_BOOL
grdpAssignInfoValueReal(const char name[], const PWP_REAL value, const bool create)
{
    return PwuAssignValueReal(GRDP_INFO_GROUP, name, value, create);
}
 
 
PWP_BOOL
grdpAssignInfoValueBool(const char name[], const bool value, const bool create)
{
    return PwuAssignValueUInt(GRDP_INFO_GROUP, name, (value ? 1 : 0), create);
}
 
 
PWP_BOOL
grdpAssignInfoValueEnum(const char name[], const char value[], const bool create)
{
    return  PwuAssignValueEnum(GRDP_INFO_GROUP, name, value, create);
}