apiGRDP.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * GRDP Plugin example
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <time.h>

#include <string>

//#define SHOW_PWP_MESSAGES
#include "apiGRDP.h"

#include "apiGRDPUtils.h"
#include "apiPWPUtils.h"
#include "apiUtils.h"
#include "PwpCwd.h"
#include "runtimeReadGrid.h"



GRDP_RTITEM grdpRtItem[] = {
    //************************************************
    // impl-defined grid import format data
    //************************************************
#   include "rtGrdpInitItems.h"
};
PWP_UINT32 grdpFormatCnt = ARRAYSIZE(grdpRtItem);



/* Safely casts the incoming GRDP_IMPORTER handle to a GRDP_RTITEM*.
   NOTE: grdpH2Rti() needs to be here to gain compile-time access
   to grdpRtItem array.
*/
static GRDP_RTITEM *
grdpH2Rti(GRDP_IMPORTER handle)
{
    GRDP_RTITEM *ret = 0;
    if (handle) {
        ptrdiff_t diff = ((char*)handle) - (char*)grdpRtItem;
        ptrdiff_t mod = diff % sizeof(grdpRtItem[0]);
        if ((0 == mod) && (0 <= diff) &&
            (diff < (ptrdiff_t)sizeof(grdpRtItem))) {
            ret = ((GRDP_RTITEM*)handle);
        }
    }
    return ret;
}



static PWP_BOOL
grdpRuntimeCreate(GRDP_RTITEM * pRti)
{
    // SDK common stuff here

    // Now, let plugin have control
    return runtimeReadGridCreate(pRti);
}


static PWP_VOID
grdpRuntimeDestroy(GRDP_RTITEM * pRti)
{
    // SDK common stuff here

    // Now, let plugin have control
    return runtimeReadGridDestroy(pRti);
}



GRDP_IMPORTER
PwCreateGrdpById(PWP_UINT32 id)
{
    GRDP_RTITEM* ret = grdpFindFormatById(id);
    if (ret && !grdpRuntimeCreate(ret)) {
        ret = 0; // grdpRuntimeCreate failed!
    }
    return (GRDP_IMPORTER)ret;
}


GRDP_IMPORTER
PwCreateGrdpByName(const char name[])
{
    GRDP_RTITEM* ret = grdpFindFormatByName(name);
    if (ret && !grdpRuntimeCreate(ret)) {
        ret = 0; // grdpRuntimeCreate failed!
    }
    return (GRDP_IMPORTER)ret;
}


PWP_VOID
PwDestroyGrdp(GRDP_IMPORTER *handle)
{
    if (handle) {
        GRDP_RTITEM* pRti = grdpH2Rti(*handle);
        if (pRti) {
            grdpRuntimeDestroy(pRti);
        }
        *handle = 0;
    }
}


const char*
PwEnumGrdpFormat(PWP_UINT32 ndx, GRDP_FORMATINFO *pFormatInfo)
{
    const char* ret = (ndx < grdpFormatCnt) ? grdpRtItem[ndx].FormatInfo.name : 0;
    if (ret && pFormatInfo) {
        *pFormatInfo = grdpRtItem[ndx].FormatInfo;
    }
    return ret;
}


PWP_UINT32
PwGetGrdpFormatCount()
{
    return grdpFormatCnt;
}


const char*
PwGrdpFormat(GRDP_IMPORTER handle, GRDP_FORMATINFO *pFormatInfo)
{
    GRDP_RTITEM *pRti = grdpH2Rti(handle);
    const char* ret = pRti ? pRti->FormatInfo.name : 0;
    if (ret && pFormatInfo) {
        *pFormatInfo = pRti->FormatInfo;
    }
    return ret;
}


class FileDestPwpCwd : public PwpCwd {
public:
    FileDestPwpCwd(const PWP_ENUM_FILEDEST id, const char *fileDest) :
        PwpCwd()
    {
        switch (id) {
        case PWP_FILEDEST_FILENAME:
        case PWP_FILEDEST_BASENAME: {
            std::string dir(fileDest);
            size_t pos = dir.rfind('/');
            if (std::string::npos != pos) {
                // if "/path/to/filename.ext" cdw to "/path/to/"
                push(dir.substr(0, pos + 1).c_str());
            }
            break; }
        case PWP_FILEDEST_FOLDER:
            push(fileDest);
            break;
        default:
            // NOP
            break;
        }
    }

    ~FileDestPwpCwd()
    {
    }
};


PWP_BOOL
PwGridRead(GRDP_IMPORTER handle, PWGM_HGRIDMODEL model,
    const GRDP_READINFO *pReadInfo)
{
    PWP_BOOL ret = PWP_FALSE;
    GRDP_RTITEM *pRti = grdpH2Rti(handle);
    if (PWGM_HGRIDMODEL_ISVALID(model)) {
        pRti->model = model;
        pRti->pReadInfo = pReadInfo;
        pRti->opAborted = PWP_FALSE;
        // make fileDest's path the cwd
        FileDestPwpCwd loc(pRti->FormatInfo.fileDest, pReadInfo->fileDest);
        // give impl control!
        ret = runtimeReadGrid(pRti);
        // loc dtor will force cwd back to original location
    }
    return ret;
}