CaePlugin.h

Go to the documentation of this file.

/****************************************************************************
 *
 * CAEP Plugin example - PwCaeGridWrite implementation
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
 
#ifndef _CAEPLUGIN_H_
#define _CAEPLUGIN_H_
 
#include "apiCAEP.h"
#include "apiCAEPUtils.h"
#include "apiGridModel.h"
#include "apiPWP.h"
#include "PwpFile.h"
 
 
template< typename MT >
class CaePlugin {
public:
 
 
    CaePlugin(CAEP_RTITEM *pRti, PWGM_HGRIDMODEL model, const CAEP_WRITEINFO
        *pWriteInfo);
 
    virtual ~CaePlugin();
 
 
    PWP_BOOL run();
 
 
    MT & model() {
        return model_;
    }
 
 
    const MT & model() const {
        return model_;
    }
 
 
    const PwpFile & runtimeFile() const {
        return rtFile_;
    }
 
    PwpFile & runtimeFile() {
        return rtFile_;
    }
 
 
    FILE * fp() const {
        return rtFile_.fp();
    }
 
 
    const char * exportDestination() const {
        return writeInfo_.fileDest;
    }
 
 
    const CAEP_FORMATINFO & formatInfo() const {
        return rti_.FormatInfo;
    }
 
 
    const PWP_APIINFO & apiInfo() const {
        return rti_.pApiData->apiInfo;
    }
 
 
 
    void setProgressMajorSteps(PWP_UINT32 steps) {
        // Do not allow zero
        progMajorSteps_ = (steps ? steps : 1);
    }
 
 
    bool progressBeginStep(PWP_UINT32 steps) const {
        return 0 != caeuProgressBeginStep(&rti_, steps);
    }
 
 
    bool progressIncrement() const {
        return 0 != caeuProgressIncr(&rti_);
    }
 
 
    bool progressEndStep() const {
        return 0 != caeuProgressEndStep(&rti_);
    }
 
 
 
    void sendInfoMsg(const char *msg, PWP_UINT32 id = 0) const {
        caeuSendInfoMsg(&rti_, msg, id);
    }
 
 
    void sendDebugMsg(const char *msg, PWP_UINT32 id = 0) const {
        caeuSendDebugMsg(&rti_, msg, id);
    }
 
 
    void sendWarningMsg(const char *msg, PWP_UINT32 id = 0) const {
        caeuSendWarningMsg(&rti_, msg, id);
    }
 
 
    void sendErrorMsg(const char *msg, PWP_UINT32 id = 0) const {
        caeuSendErrorMsg(&rti_, msg, id);
    }
 
 
    bool aborted() const {
        return 0 != rti_.opAborted;
    }
 
 
 
    bool conditionsOnly() const {
        return 0 != writeInfo_.conditionsOnly;
    }
 
 
    PWP_ENUM_PRECISION precision() const {
        return writeInfo_.precision;
    }
 
 
    bool isSinglePrecision() const {
        return PWP_PRECISION_SINGLE == precision();
    }
 
 
    bool isDoublePrecision() const {
        return PWP_PRECISION_DOUBLE == precision();
    }
 
 
    const char * precisionStr() const {
        return CAEPU_RT_PREC_TEXT(&rti_);
    }
 
 
    PWP_ENUM_ENCODING encoding() const {
        return writeInfo_.encoding;
    }
 
 
    bool isAsciiEncoding() const {
        return PWP_ENCODING_ASCII == encoding();
    }
 
 
    bool isBinaryEncoding() const {
        return PWP_ENCODING_BINARY == encoding();
    }
 
 
    bool isUnformattedEncoding() const {
        return PWP_ENCODING_UNFORMATTED == encoding();
    }
 
 
    const char * encodingStr() const {
        return CAEPU_RT_ENCODING_TEXT(&rti_);
    }
 
 
    PWP_ENUM_DIMENSION dimension() const {
        return writeInfo_.dimension;
    }
 
 
    bool isDimension3D() const {
        return PWP_DIMENSION_3D == dimension();
    }
 
 
    bool isDimension2D() const {
        return PWP_DIMENSION_2D == dimension();
    }
 
 
    const char * dimensionStr() const {
        return CAEPU_RT_DIM_TEXT(&rti_);
    }
 
 
    PWP_ENDIANNESS byteOrder() const {
        // Force return to be one of PWP_ENDIAN_LITTLE or PWP_ENDIAN_BIG
        return PwpFile::mapToBigLittle(writeInfo_.byteOrder);
    }
 
 
    bool isBigEndian() const {
        return PWP_ENDIAN_BIG == byteOrder();
    }
 
 
    bool isLittleEndian() const {
        return PWP_ENDIAN_LITTLE == byteOrder();
    }
 
 
    bool isLicensed(const PWP_LICENSEDATA &license) const {
        return 0 != PwpIsLicensed(rti_.pApiData->apiInfo.name, &license);
    }
 
 
    void setLanguage(const char language[]) {
        return PwpSetLanguage(language);
    }
 
 
    static PWP_ENDIANNESS getOsEndianness() {
        return PwuGetOsEndianness();
    }
 
 
    static PWP_VERSIONVAL getInfo(PWP_PLUGININFO &pluginInfo) {
        return PwpGetPluginInfo(&pluginInfo);
    }
 
 
    static PWP_VERSION getApiVersion() {
        PWP_PLUGININFO info;
        PwpGetPluginInfo(&info);
        return info.pwpVer;
    }
 
 
    static PWP_VERSION getVersion() {
        PWP_PLUGININFO info;
        PwpGetPluginInfo(&info);
        return info.libVer;
    }
 
 
    static const char * getAuthorInfo() {
        PWP_PLUGININFO info;
        PwpGetPluginInfo(&info);
        return info.author;
    }
 
 
    static const char * getSupportInfo() {
        PWP_PLUGININFO info;
        PwpGetPluginInfo(&info);
        return info.support;
    }
 
 
    static const char * getCopyrightInfo() {
        PWP_PLUGININFO info;
        PwpGetPluginInfo(&info);
        return info.copyright;
    }
 
 
    template< typename H >
    static bool isValid(H h) {
        return PWP_HEGRP_ISVALID(h);
    }
 
 
    static bool isValid(PWGM_HELEMENT h) {
        return PWGM_HELEMENT_ISVALID(h);
    }
 
 
 
    static bool publishValueDef(CAEP_RTITEM &rti, const char key[],
            PWP_ENUM_VALTYPE type, const char value[], const char desc[],
            const char range[] = "", const char access[] = "RW") {
        (void)rti.BCCnt; // silence unused arg warning
        return 0 !=  caeuPublishValueDefinition(key, type, value, access,
                        desc, range);
    }
 
 
    static bool publishUIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_UINT value, const char desc[], const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%lu", (unsigned long)value);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_UINT, valBuf,
                        access, desc, "");
    }
 
 
    static bool publishUIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_UINT value, const char desc[], PWP_UINT minVal, PWP_UINT maxVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%lu", (unsigned long)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%lu %lu", (unsigned long)minVal,
            (unsigned long)maxVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_UINT, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishUIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_UINT value, const char desc[], PWP_UINT minVal, PWP_UINT maxVal,
        PWP_UINT minTypicalVal, PWP_UINT maxTypicalVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%lu", (unsigned long)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%lu %lu %lu %lu", (unsigned long)minVal,
            (unsigned long)maxVal, (unsigned long)minTypicalVal,
            (unsigned long)maxTypicalVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_UINT, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_INT value, const char desc[], const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%ld", (long)value);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_INT, valBuf,
                        access, desc, "");
    }
 
 
    static bool publishIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_INT value, const char desc[], PWP_INT minVal, PWP_INT maxVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%ld", (long)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%ld %ld", (long)minVal, (long)maxVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_INT, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishIntValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_INT value, const char desc[], PWP_INT minVal, PWP_INT maxVal,
        PWP_INT minTypicalVal, PWP_INT maxTypicalVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%ld", (long)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%ld %ld %ld %ld", (long)minVal, (long)maxVal,
            (long)minTypicalVal, (long)maxTypicalVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_INT, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishRealValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_REAL value, const char desc[], const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%g", (double)value);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_REAL, valBuf,
                        access, desc, "");
    }
 
 
    static bool publishRealValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_REAL value, const char desc[], PWP_REAL minVal, PWP_REAL maxVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%g", (double)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%g %g", minVal, maxVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_REAL, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishRealValueDef(CAEP_RTITEM &rti, const char key[],
        PWP_REAL value, const char desc[], PWP_REAL minVal, PWP_REAL maxVal,
        PWP_REAL minTypicalVal, PWP_REAL maxTypicalVal,
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        char valBuf[64];
        sprintf(valBuf, "%g", (double)value);
        char rangeBuf[128];
        sprintf(rangeBuf, "%g %g %g %g", minVal, maxVal, minTypicalVal,
            maxTypicalVal);
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_REAL, valBuf,
                        access, desc, rangeBuf);
    }
 
 
    static bool publishBoolValueDef(CAEP_RTITEM &rti, const char key[],
        bool value, const char desc[], const char range[] = "",
        const char access[] = "RW")
    {
        (void)rti.BCCnt; // silence unused arg warning
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_BOOL,
                        (value ? "1" : "0"), access, desc, range);
    }
 
 
    static bool publishStringValueDef(CAEP_RTITEM &rti, const char key[],
            const char value[], const char desc[], const char range[] = "",
            const char access[] = "RW") {
        (void)rti.BCCnt; // silence unused arg warning
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_STRING, value,
                        access, desc, range);
    }
 
 
    static bool publishEnumValueDef(CAEP_RTITEM &rti, const char key[],
            const char value[], const char desc[], const char range[] = "",
            const char access[] = "RW") {
        (void)rti.BCCnt; // silence unused arg warning
        return 0 !=  caeuPublishValueDefinition(key, PWP_VALTYPE_ENUM, value,
                        access, desc, range);
    }
 
 
    static bool assignInfoValue(CAEP_RTITEM &rti, const char key[],
        const char value[], const bool createIfNotExists = true) {
        (void)rti.BCCnt; // silence unused arg warning
        return 0 != caeuAssignInfoValue(key, value, createIfNotExists);
    }
 
 
    static bool allowByteOrders(CAEP_RTITEM &rti, const bool big,
            const bool little) {
        const char * const vals[] = {
            /* 0 */ 0, // erase "AllowedFileByteOrders" info value
            /* 1 */ "LittleEndian",
            /* 2 */ "BigEndian",
            /* 3 */ "BigEndian|LittleEndian"
        };
        const int n = (big ? 2 : 0) + (little ? 1 : 0);
        return assignInfoValue(rti, "AllowedFileByteOrders", vals[n], true);
    }
 
 
    static bool allowElementTopologies(CAEP_RTITEM &rti, const bool structured,
        const bool unstructured, const bool prismatic) {
        const char * const vals[] = {
            /* 0 */ 0, // erase "AllowedElementTopologies" info value
            /* 1 */ "Structured",
            /* 2 */ "Unstructured",
            /* 3 */ "Structured|Unstructured",
            /* 4 */ "Prismatic",
            /* 5 */ "Structured|Prismatic",
            /* 6 */ "Unstructured|Prismatic",
            /* 7 */ "Structured|Unstructured|Prismatic",
        };
        const int n = (prismatic ? 4 : 0) + (unstructured ? 2 : 0) +
            (structured ? 1 : 0);
        return assignInfoValue(rti, "AllowedElementTopologies", vals[n], true);
    }
 
 
    static bool meshLinkSupported(CAEP_RTITEM &rti, const bool on) {
        return assignInfoValue(rti, "MeshLinkSupported", (on ? "1" : "0"));
    }
 
 
    static bool useZeroBasedIndexing(CAEP_RTITEM &rti) {
        return assignInfoValue(rti, "IndexScheme", "ZeroBased");
    }
 
 
    static bool useOneBasedIndexing(CAEP_RTITEM &rti) {
        return assignInfoValue(rti, "IndexScheme", "OneBased");
    }
 
 
    static bool useCustomIndexing(CAEP_RTITEM &rti) {
        return assignInfoValue(rti, "IndexScheme", "Custom");
    }
 
 
    static bool shadowBcTypes(CAEP_RTITEM &rti, const char * const shadowTypes)
    {
        return assignInfoValue(rti, "ShadowBcTypes", shadowTypes, true);
    }
 
private:
 
 
    virtual bool beginExport()
    {
        return true;
    }
 
 
    virtual PWP_BOOL write() = 0;
 
 
    virtual bool endExport()
    {
        return true;
    }
 
    CaePlugin(const CaePlugin &src);
 
    CaePlugin & operator=(const CaePlugin &rhs);
 
 
    void wrapRuntimeFile() {
        if (nullptr != rti_.fp) {
            int mode = 0;
            switch (encoding()) {
            case PWP_ENCODING_ASCII:
                mode = pwpWrite | pwpAscii;
                break;
            case PWP_ENCODING_BINARY:
                mode = pwpWrite | pwpBinary;
                break;
            case PWP_ENCODING_UNFORMATTED:
                mode = pwpWrite | pwpUnformatted;
                break;
            default:
                break;
            }
            rtFile_.wrap(rti_.fp, exportDestination(), mode);
            rti_.fp = nullptr; // rtFile_ now owns rti_.fp
        }
        else {
            rtFile_.wrap(nullptr);
        }
        rtFile_.setByteOrder(byteOrder());
        rtFile_.setPrecision(precision());
    }
 
protected:
    CAEP_RTITEM &           rti_; 
    MT                      model_; 
    const CAEP_WRITEINFO &  writeInfo_; 
    PWP_UINT32              progMajorSteps_; 
    PwpFile                 rtFile_; 
};
 
#include "CaePluginImpl.h"
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
#if !defined(PWGM_HIDE_UNSTRUCTURED_API)
#include "CaeUnsGridModel.h"
 
typedef CaePlugin<CaeUnsGridModel> CaeUnsPlugin;
#endif
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
#if !defined(PWGM_HIDE_STRUCTURED_API)
#include "CaeStrGridModel.h"
 
typedef CaePlugin<CaeStrGridModel> CaeStrPlugin;
#endif
 
#endif // _CAEPLUGIN_H_