zoukankan      html  css  js  c++  java
  • ProSolid下的遍历访问封装代码

      在ProE二次开发中,时常需要遍历ProSolid下的面、点、轴等几何元素。我们知道,ProToolkit下的遍历函数还是有点小麻烦的,而ProWebLink中就简单很多,比如要遍历某ProSolid下的所有Group,代码如下:

    1 var  groupList = sld.ListGroups();
    2 for (var i=0; i<groupList.Count; ++i)
    3 {
    4   ...
    5 }

      那么,ProToolkit下是否可以封装类似的代码呢?当然可以。

      先贴一段我封装之后遍历访问ProSolid下所有Datum Point的代码:

     1     ProError err;
     2     ProMdl mdl_curr;
     3     err = ProMdlCurrentGet(&mdl_curr);
     4     
     5     try
     6     {
     7         // 利用当前Model构造CProSolid对象,并遍历访问其下的所有Datum Point
     8         CProSolid sld((ProSolid)mdl_curr);
     9         CProList<ProPoint> pntList = sld.ListPoints();
    10         CString cstr;
    11         cstr.Format(TEXT("%d"), pntList.size());
    12         AfxMessageBox(cstr);
    13 
    14         // 对每个Datum Point执行操作
    15         for (int i=0; i<pntList.size(); ++i)
    16         {
    17             ProPoint pnt = pntList[i];
    18             int id;
    19             err = ProPointIdGet(pnt, &id);
    20             CString cstr;
    21             cstr.Format(TEXT("Point Id: %d."), id);
    22             AfxMessageBox(cstr);
    23         }
    24 
    25     }
    26     catch (exception& e)
    27     {
    28         AfxMessageBox(TEXT("exception."));
    29     }

    再贴上我封装的代码:

    1、CProArray.h    在前一篇博文<<类似vector的ProArray封装类CProArray>>中已贴出。

    2、CProList.h

    View Code
      1 #ifndef _C_PRO_LIST_H_
      2 #define _C_PRO_LIST_H_
      3 
      4 #include <ProToolkit.h>
      5 #include "CProArray.h"
      6 #include <exception>
      7 #include <stdexcept>
      8 
      9 using std::exception;
     10 using std::out_of_range;
     11 using std::bad_alloc;
     12 
     13 template<class TYPE, size_t reallocationSize = 5>
     14 class CProList
     15 {
     16 public:
     17     CProList() 
     18         //throw(bad_alloc)
     19         : m_pArr(new CProArray<TYPE, reallocationSize>())
     20     {}
     21 
     22     CProList(const CProList& rhs)
     23         : m_pArr(rhs.m_pArr)
     24     {
     25         ++(m_pArr->use);
     26     }
     27 
     28     CProList& operator=(const CProList& rhs)
     29     {
     30         if (--(m_pArr->use) == 0)
     31             delete m_pArr;
     32         ++(rhs.m_pArr->use);
     33         m_pArr = rhs.m_pArr;
     34     }
     35 
     36     ~CProList()
     37     {
     38         if (--(m_pArr->use) == 0)
     39             delete m_pArr;
     40     }
     41 
     42 public:
     43     size_t size() const
     44     {
     45         return m_pArr->size();
     46     }
     47 
     48     bool is_empty() const
     49     {
     50         return m_pArr->is_empty();
     51     }
     52 
     53     void clear()
     54     {
     55         m_pArr->clear();
     56     }
     57 
     58     void push_back(const TYPE& val)
     59     {
     60         m_pArr->push_back(val);
     61     }
     62 
     63     void pop_back()
     64     {
     65         m_pArr->pop_back();
     66     }
     67 
     68     const TYPE& front() const 
     69         //throw(out_of_range)
     70     {
     71         try
     72         {
     73             return m_pArr->front();
     74         }
     75         catch (const out_of_range&)
     76         {
     77             throw out_of_range("empty CProList.");
     78         }
     79         catch (...)
     80         {
     81             throw;
     82         }
     83     }
     84 
     85     TYPE& front() 
     86         //throw(out_of_range)
     87     {
     88         return const_cast<TYPE&>(const_cast<const CProList*>(this)->front());
     89     }
     90 
     91     const TYPE& back() const 
     92         //throw(out_of_range)
     93     {
     94         try
     95         {
     96             return m_pArr->back();
     97         }
     98         catch (const out_of_range&)
     99         {
    100             throw out_of_range("empty CProList.");
    101         }
    102         catch (...)
    103         {
    104             throw;
    105         }
    106     }
    107 
    108     TYPE& back() 
    109         //throw(out_of_range)
    110     {
    111         return const_cast<TYPE&>(const_cast<const CProList*>(this)->back());
    112     }
    113 
    114     const TYPE& operator[](size_t index) const 
    115         //throw(out_of_range)
    116     {
    117         if (is_empty())
    118             throw out_of_range("empty CProList.");
    119         try
    120         {
    121             return m_pArr->operator[](index);
    122         }
    123         catch (const out_of_range&)
    124         {
    125             throw out_of_range("invalid index of CProList.");
    126         }
    127         catch (...)
    128         {
    129             throw;
    130         }
    131     }
    132 
    133     TYPE& operator[](size_t index)
    134         //throw(out_of_range)
    135     {
    136         return const_cast<TYPE&>(const_cast<const CProList*>(this)->operator[](index));
    137     }
    138 
    139     const TYPE& at(size_t index) const 
    140         //throw(out_of_range)
    141     {
    142         if (is_empty())
    143             throw out_of_range("empty CProList.");
    144         try
    145         {
    146             return m_pArr->at(index);
    147         }
    148         catch (const out_of_range&)
    149         {
    150             throw out_of_range("invalid index of CProList.");
    151         }
    152         catch (...)
    153         {
    154             throw;
    155         }
    156     }
    157 
    158     TYPE& at(size_t index) 
    159         //throw(out_of_range)
    160     {
    161         return const_cast<TYPE&>(const_cast<const CProList*>(this)->at(index));
    162     }
    163 
    164     void insert_at(size_t index, const TYPE& val) 
    165         //throw(out_of_range, bad_alloc)
    166     {
    167         if (size() < index)
    168             throw out_of_range("invalid index of CProList.");
    169 
    170         m_pArr->insert_at(index, val);
    171     }
    172 
    173     void insert_at(size_t index, size_t cnt, const TYPE *pVal) 
    174         //throw(out_of_range, bad_alloc)
    175     {
    176         if (size() < index)
    177             throw out_of_range("invalid index of CProList.");
    178 
    179         m_pArr->insert_at(index, cnt, pVal);
    180     }
    181 
    182     void remove_at(size_t index, size_t cnt = 1) 
    183         //throw(out_of_range)
    184     {
    185         if (size() <= index)
    186             throw out_of_range("invalid index of CProList.");
    187         if (size() - index < cnt)
    188             throw out_of_range("count to remove is out of range");
    189 
    190         m_pArr->remove_at(index, cnt);
    191     }
    192 
    193     operator ProArray() const
    194     {
    195         return m_pArr->operator ProArray();
    196     }
    197 
    198 private:
    199     CProArray<TYPE, reallocationSize> *m_pArr;
    200 };
    201 
    202 #endif

    3、CProSolid.h

    View Code
      1 #ifndef _C_PRO_SOLID_H_
      2 #define _C_PRO_SOLID_H_
      3 
      4 #include <ProToolkit.h>
      5 #include <ProSolid.h>
      6 #include <ProCsys.h>
      7 #include <ProSurface.h>
      8 #include <ProAxis.h>
      9 #include <ProPoint.h>
     10 #include <ProQuilt.h>
     11 #include <ProFeature.h>
     12 #include <profeattype.h>
     13 #include "CProList.h"
     14 #include <exception>
     15 
     16 ProError _VisitSolidAllCsyses_(ProCsys  p_csys,
     17                                ProAppData app_data);
     18 
     19 ProError _VisitSolidAllSurfs_(ProSurface p_surface,
     20                               ProAppData app_data);
     21 
     22 ProError _VisitSolidAllAxises_(ProAxis  p_axis,
     23                                ProAppData app_data);
     24 
     25 ProError _VisitSolidAllQuilts_(ProQuilt p_quilt,
     26                                ProAppData app_data);
     27 
     28 ProError _VisitSolidAllFeats_(ProFeature* p_feature,
     29                               ProAppData app_data);
     30 
     31 ProError _VisitFeatAllPoints_(ProGeomitem *p_handle,
     32                               ProAppData  app_data);
     33 
     34 ProError _VisitQuiltAllSurfaces_(ProSurface surface,
     35                                  ProAppData app_data);
     36 
     37 ProError _VisitSolidAllDatumPlaneFeats_(ProFeature* p_feature,
     38                                         ProAppData app_data);
     39 
     40 class CProSolid
     41 {
     42 public:
     43     explicit CProSolid(ProSolid sld) : m_sld(sld) {}
     44 
     45     //
     46     // 列出所有的坐标系
     47     // 
     48     CProList<ProCsys> ListCsyses()
     49     {
     50         ProError err;
     51         CProList<ProCsys> csysList;
     52         err = ProSolidCsysVisit(m_sld, NULL, _VisitSolidAllCsyses_, &csysList);
     53         if (err != PRO_TK_NO_ERROR 
     54             && err != PRO_TK_E_NOT_FOUND)
     55             throw exception("ListCsyses() failed.");
     56 
     57         return csysList;
     58     }
     59 
     60     //
     61     // 列出所有的soild surface
     62     //
     63     CProList<ProSurface> ListSurfaces()
     64     {
     65         ProError err;
     66         CProList<ProSurface> surfList;
     67         err = ProSolidSurfaceVisit(m_sld, NULL, _VisitSolidAllSurfs_, &surfList);
     68         if (err != PRO_TK_NO_ERROR
     69             && err != PRO_TK_E_NOT_FOUND)
     70             throw exception("ListSurfaces failed.");
     71 
     72         return surfList;
     73     }
     74 
     75     //
     76     // 列出所有的datum surface
     77     //
     78     CProList<ProSurface> ListDatumSurfaces()
     79     {
     80         ProError err;
     81         CProList<ProSurface> datumSurfList;
     82 
     83         // get all quilts
     84         CProList<ProQuilt> quiltList;
     85         err = ProSolidQuiltVisit(m_sld, NULL, _VisitSolidAllQuilts_, &quiltList);
     86         if (err != PRO_TK_NO_ERROR
     87             && err != PRO_TK_E_NOT_FOUND)
     88             throw exception("ListDatumSurfaces failed.");
     89 
     90         // get all datum surfaces in every quilt
     91         for (int i=0; i<quiltList.size(); ++i)
     92         {
     93             err = ProQuiltSurfaceVisit(quiltList[i], NULL, 
     94                 _VisitQuiltAllSurfaces_, &datumSurfList);
     95             if (err != PRO_TK_NO_ERROR
     96                 && err != PRO_TK_E_NOT_FOUND)
     97                 throw exception("ListDatumSurfaces failed.");
     98         }
     99 
    100         return datumSurfList;
    101     }
    102 
    103     //
    104     // 列出所有的datum plane
    105     //
    106     CProList<ProSurface> ListDatumPlanes()
    107     {
    108         ProError err;
    109         CProList<ProSurface> datumPlaneList;
    110     
    111         // get all feats which feat type is PRO_FEAT_DATUM
    112         CProList<ProFeature> datumPlaneFeatList;
    113         err = ProSolidFeatVisit(m_sld, NULL, _VisitSolidAllDatumPlaneFeats_, &datumPlaneFeatList);
    114         if (err != PRO_TK_NO_ERROR
    115             && err != PRO_TK_E_NOT_FOUND)
    116             throw exception("ListDatumPlanes failed.");
    117 
    118         // get datum plane in every datum plane feat
    119         // but exclude which is inactive
    120         for (int i=0; i<datumPlaneFeatList.size(); ++i)
    121         {
    122             ProSurface datumPlane;
    123             err = ProSurfaceInit(datumPlaneFeatList[i].owner, datumPlaneFeatList[i].id+1, 
    124                 &datumPlane);
    125             ProGeomitem surf_geom_item;
    126             err = ProSurfaceToGeomitem(m_sld, datumPlane, &surf_geom_item);
    127             ProBoolean bIsInActive;
    128             err = ProGeomitemIsInactive(&surf_geom_item, &bIsInActive);
    129 
    130             if (bIsInActive == PRO_B_FALSE)
    131                 datumPlaneList.push_back(datumPlane);
    132         }
    133 
    134         return datumPlaneList;
    135     }
    136 
    137     //
    138     // 列出所有的轴
    139     //
    140     CProList<ProAxis> ListAxises()
    141     {
    142         ProError err;
    143         CProList<ProAxis> axisList;
    144         err = ProSolidAxisVisit(m_sld, NULL, _VisitSolidAllAxises_, &axisList);
    145         if (err != PRO_TK_NO_ERROR
    146             && err != PRO_TK_E_NOT_FOUND)
    147             throw exception("ListAxises failed.");
    148 
    149         return axisList;
    150     }
    151 
    152     //
    153     // 列出所有的Datum Points
    154     // Note: 不包含Inactive的Datum Point
    155     //
    156     CProList<ProPoint> ListPoints()
    157     {
    158         ProError err;
    159         CProList<ProPoint> pntList;
    160 
    161         // get all feats
    162         CProList<ProFeature> featList;
    163         err = ProSolidFeatVisit(m_sld, NULL, _VisitSolidAllFeats_, &featList);
    164         if (err != PRO_TK_NO_ERROR
    165             && err != PRO_TK_E_NOT_FOUND)
    166             throw exception("ListPoints failed.");
    167 
    168         // get all points in every feat but exclude which is inactive
    169         for (int i=0; i<featList.size(); ++i)
    170         {
    171             CProList<ProGeomitem> pntGeomitemList;
    172             err = ProFeatureGeomitemVisit(&featList[i], PRO_POINT, NULL, 
    173                 _VisitFeatAllPoints_, &pntGeomitemList);
    174             if (err != PRO_TK_NO_ERROR
    175                 && err != PRO_TK_E_NOT_FOUND)
    176                 throw exception("ListPoints failed.");
    177             for (int i=0; i<pntGeomitemList.size(); ++i)
    178             {
    179                 ProBoolean bIsInActive;
    180                 ProGeomitemIsInactive(&pntGeomitemList[i], &bIsInActive);
    181                 if (bIsInActive == PRO_B_TRUE)
    182                     break;
    183                 ProPoint pnt;
    184                 ProGeomitemToPoint(&pntGeomitemList[i], &pnt);
    185                 pntList.push_back(pnt);
    186             }
    187         }
    188         
    189         return pntList;
    190     }
    191 
    192     //
    193     // 列出所有的面組
    194     //
    195     CProList<ProQuilt> ListQuilts()
    196     {
    197         ProError err;
    198         CProList<ProQuilt> quiltList;
    199         err = ProSolidQuiltVisit(m_sld, NULL, _VisitSolidAllQuilts_, &quiltList);
    200         if (err != PRO_TK_NO_ERROR
    201             && err != PRO_TK_E_NOT_FOUND)
    202             throw exception("ListQuilts failed.");
    203 
    204         return quiltList;
    205     }
    206 
    207     //
    208     // 列出所有的特征
    209     //
    210     CProList<ProFeature> ListFeats()
    211     {
    212         ProError err;
    213         CProList<ProFeature> featList;
    214         err = ProSolidFeatVisit(m_sld, NULL, _VisitSolidAllFeats_, &featList);
    215         if (err != PRO_TK_NO_ERROR
    216             && err != PRO_TK_E_NOT_FOUND)
    217             throw exception("ListFeats failed.");
    218 
    219         return featList;
    220     }
    221 
    222 public:
    223     ProSolid m_sld;
    224 };
    225 
    226 #endif

    4、CProSolid.cpp

    View Code
     1 #include "CProSolid.h"
     2 
     3 ProError _VisitSolidAllCsyses_(ProCsys  p_csys,
     4                                ProAppData app_data)
     5 {
     6     CProList<ProCsys> *pCsysList = (CProList<ProCsys>*)app_data;
     7     pCsysList->push_back(p_csys);
     8 
     9     return PRO_TK_NO_ERROR;
    10 }
    11 
    12 ProError _VisitSolidAllSurfs_(ProSurface p_surface,
    13                               ProAppData app_data)
    14 {
    15     CProList<ProSurface> *pSurfList = (CProList<ProSurface>*)app_data;
    16     pSurfList->push_back(p_surface);
    17 
    18     return PRO_TK_NO_ERROR;
    19 }
    20 
    21 ProError _VisitSolidAllAxises_(ProAxis  p_axis,
    22                                ProAppData app_data)
    23 {
    24     CProList<ProAxis> *pAxisList = (CProList<ProAxis>*)app_data;
    25     pAxisList->push_back(p_axis);
    26 
    27     return PRO_TK_NO_ERROR;
    28 }
    29 
    30 ProError _VisitSolidAllQuilts_(ProQuilt p_quilt,
    31                                ProAppData app_data)
    32 {
    33     CProList<ProQuilt> *pQuiltList = (CProList<ProQuilt>*)app_data;
    34     pQuiltList->push_back(p_quilt);
    35 
    36     return PRO_TK_NO_ERROR;
    37 }
    38 
    39 ProError _VisitSolidAllFeats_(ProFeature* p_feature,
    40                               ProAppData app_data)
    41 {
    42     CProList<ProFeature> *pFeatList = (CProList<ProFeature>*)app_data;
    43     pFeatList->push_back(*p_feature);
    44 
    45     return PRO_TK_NO_ERROR;
    46 }
    47 
    48 ProError _VisitFeatAllPoints_(ProGeomitem *p_handle,
    49                               ProAppData  app_data)
    50 {
    51     CProList<ProGeomitem> *pPntGeomitemList = (CProList<ProGeomitem>*)app_data;
    52     pPntGeomitemList->push_back(*p_handle);
    53 
    54     return PRO_TK_NO_ERROR;
    55 }
    56 
    57 ProError _VisitQuiltAllSurfaces_(ProSurface p_surface,
    58                                  ProAppData app_data)
    59 {
    60     CProList<ProSurface> *pDatumSurfaceList = (CProList<ProSurface>*)app_data;
    61     pDatumSurfaceList->push_back(p_surface);
    62 
    63     return PRO_TK_NO_ERROR;
    64 }
    65 
    66 ProError _VisitSolidAllDatumPlaneFeats_(ProFeature* p_feature,
    67                                         ProAppData app_data)
    68 {
    69     CProList<ProFeature> *pDatumPlaneFeatList = (CProList<ProFeature>*)app_data;
    70     ProError err;
    71     ProFeattype feat_type;
    72     err = ProFeatureTypeGet(p_feature, &feat_type);
    73     if (feat_type == PRO_FEAT_DATUM)
    74         pDatumPlaneFeatList->push_back(*p_feature);
    75 
    76     return PRO_TK_NO_ERROR;
    77 }

     使用及代码说明:

    1、使用时请包含以下头文件即可:

         #include "CProArray.h" 

      #include "CProList.h" 

      #include "CProSolid.h" 

    2、之所以可以向WebLink那样使用,关键是CProList类的封装,该类有一个CProArray类的指针,并且CProArray类中包含一个引用计数,表明当前有多少个CProList对象引用了CProArray对象,这样,CProList对象的直接赋值实际上并没有重新分配数组对象,仅仅是增加了引用的数组CProArray的引用计数。

    3、CProList对象会自动释放申请的数组内存,当引用计数变为0时。所以,使用者无需自己释放数组内存。

  • 相关阅读:
    功能测试--评论测试点
    airtest自动化测试工具使用
    jmeter录制脚本失败原因(windows为例)
    测试APP电量、内存、网络流量工具----GT
    Java--使用反编译工具,打开jar包,查看源码
    jmeter(图片进行base64加密发送)
    jmeter之永久性修改为中文显示界面方法
    jmeter之发送请求失败,乌龙---千万不要在请求体的写注释
    jmeter使用BeanShell进行简单的base64加密
    使用JS报错 xx is not defined at HTMLAnchorElement.onclick
  • 原文地址:https://www.cnblogs.com/Hisin/p/2613698.html
Copyright © 2011-2022 走看看