CaeGridModel.h

Go to the documentation of this file.

/****************************************************************************
 *
 * CaeGridModel class
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
 
#ifndef _CAEGRIDMODEL_H_
#define _CAEGRIDMODEL_H_
 
#include "apiGridModel.h"
#include "apiPWP.h"
 
 
class CaeGridModel {
protected:
 
    CaeGridModel(PWGM_HGRIDMODEL model);
 
 
    CaeGridModel(const CaeGridModel &src);
 
    ~CaeGridModel();
 
public:
    PWP_UINT32  blockCount() const;
 
 
    bool getAttribute(const char *name, const char *&val, const char *defVal) const;
    bool getAttribute(const char *name, PWP_UINT &val, PWP_UINT defVal) const;
    bool getAttribute(const char *name, PWP_UINT32 &val, PWP_UINT32 defVal) const;
    bool getAttribute(const char *name, PWP_INT &val, PWP_INT defVal) const;
    bool getAttribute(const char *name, PWP_INT32 &val, PWP_INT32 defVal) const;
    bool getAttribute(const char *name, PWP_REAL &val, PWP_REAL defVal) const;
    bool getAttribute(const char *name, PWP_FLOAT &val, PWP_FLOAT defVal) const;
    bool getAttribute(const char *name, bool &val, bool defVal) const;
    bool getAttributeEnum(const char *name, const char *&val, const char *defVal) const;
 
 
    template< typename T >
    bool getAttribute(const char *name, T &val) const
    {
        return getAttribute(name, val, val);
    }
 
 
    CaeGridModel & operator= (const CaeGridModel &rhs);
 
    operator PWGM_HGRIDMODEL() const {
        return model_;
    }
 
protected:
    PWGM_HGRIDMODEL model_; 
};
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
bool    operator==(const PWGM_HBLOCK &h1, const PWGM_HBLOCK &h2);
bool    operator!=(const PWGM_HBLOCK &h1, const PWGM_HBLOCK &h2);
bool    operator<(const PWGM_HBLOCK &h1, const PWGM_HBLOCK &h2);
bool    operator>(const PWGM_HBLOCK &h1, const PWGM_HBLOCK &h2);
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
class CaeBlock {
protected:
 
 
    CaeBlock(const CaeBlock &src) {
        block_ = src.block_;
    }
 
    ~CaeBlock() {
    }
 
public:
 
 
    PWP_UINT32 index() const {
        return PWGM_HBLOCK_ID(block_);
    }
 
 
    bool condition(PWGM_CONDDATA &condData) const {
        return 0 != PwBlkCondition(block_, &condData);
    }
 
 
    bool data(PWGM_BLOCKDATA &data) {
        return 0 != PwBlock(block_, &data);
    }
 
 
    bool setExportName(const char *name) {
        return 0 != PwBlkSetExportName(block_, name);
    }
 
    bool isValid() const {
        return PWGM_HBLOCK_ISVALID(block_);
    }
 
 
    CaeBlock& operator=(const CaeBlock& rhs) {
        block_ = rhs.block_;
        return *this;
    }
 
 
    CaeBlock& operator=(PWGM_HBLOCK block) {
        block_ = block;
        return *this;
    }
 
 
    CaeBlock& moveTo(PWGM_HGRIDMODEL model, PWP_UINT32 ndx) {
        block_ = PwModEnumBlocks(model, ndx);
        return *this;
    }
 
 
    CaeBlock& moveFirst(PWGM_HGRIDMODEL model) {
        return moveTo(model, 0);
    }
 
 
    CaeBlock& moveNext() {
        block_ = PwModEnumBlocks(PWGM_HBLOCK_H(block_),
                    PWGM_HBLOCK_ID(block_) + 1);
        return *this;
    }
 
 
    CaeBlock& operator++() { // pre incr to next block
        return moveNext();
    }
 
 
    CaeBlock operator++(int) { // post incr to next block
        CaeBlock ret = *this;
        operator++();
        return ret;
    }
 
 
    CaeBlock& movePrev() { // move to previous block
        block_ = PwModEnumBlocks(PWGM_HBLOCK_H(block_),
                    PWGM_HBLOCK_ID(block_) - 1);
        return *this;
    }
 
 
    CaeBlock& operator--() { // pre decr to previous block
        return movePrev();
    }
 
 
    CaeBlock operator--(int) { // post decr to previous block
        CaeBlock ret = *this;
        operator--();
        return ret;
    }
 
    friend bool operator==(const PWGM_HBLOCK &b1, const PWGM_HBLOCK &b2);
 
 
    bool operator==(const CaeBlock &rhs) const {
        return rhs.block_ == block_;
    }
 
    operator PWGM_HBLOCK() const {
        return block_;
    }
 
protected:
 
 
    CaeBlock() {
        PWGM_HBLOCK badBlk = PWGM_HBLOCK_INIT;
        block_ = badBlk;
    }
 
 
    CaeBlock(PWGM_HBLOCK block) : block_(block) {
    }
 
 
    CaeBlock(PWGM_HGRIDMODEL model, PWP_UINT32 ndx = 0) {
        moveTo(model, ndx);
    }
 
protected:
 
    PWGM_HBLOCK block_; 
};
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
class CaeCondition {
public:
 
    static const PWP_UINT32 UnspecifiedId = PWGM_UNSPECIFIED_COND_ID;
 
    static const PWP_UINT32 UnspecifiedTypeId = PWGM_UNSPECIFIED_TYPE_ID;
 
public:
 
 
    CaeCondition()
    {
        cd_.name = 0;
        cd_.id = UnspecifiedId;
        cd_.type = 0;
        cd_.tid = UnspecifiedTypeId;
    }
 
 
    CaeCondition(const CaeCondition &src)
    {
        cd_ = src.cd_;
    }
 
 
    CaeCondition(const PWGM_CONDDATA &cd)
    {
        cd_ = cd;
    }
 
 
    ~CaeCondition()
    {
    }
 
 
    inline const char *
    name() const
    {
        return cd_.name;
    }
 
 
    inline PWP_UINT32
    id() const
    {
        return cd_.id;
    }
 
 
    inline const char *
    typeName() const
    {
        return cd_.type;
    }
 
 
    inline PWP_UINT32
    typeId() const
    {
        return cd_.tid;
    }
 
 
    inline bool
    isOfType(PWP_UINT32 tid) const
    {
        return cd_.tid == tid;
    }
 
 
    inline bool
    hasUnspecifiedId() const
    {
        return UnspecifiedId == cd_.id;
    }
 
 
    inline bool
    hasUnspecifiedType() const
    {
        return UnspecifiedTypeId == cd_.tid;
    }
 
 
 
    inline bool
    isUnspecified() const
    {
        return hasUnspecifiedId() || hasUnspecifiedType();
    }
 
 
    CaeCondition& operator=(const CaeCondition &src)
    {
        cd_ = src.cd_;
        return *this;
    }
 
 
    CaeCondition& operator=(const PWGM_CONDDATA &cd)
    {
        cd_ = cd;
        return *this;
    }
 
 
    operator PWGM_CONDDATA&()
    {
        return cd_;
    }
 
 
    operator const PWGM_CONDDATA&() const
    {
        return cd_;
    }
 
 
private:
    PWGM_CONDDATA cd_;
};
 
#endif