Introduction

Getting Started

Programming Guides

API Reference

Additional Resources

ExchangeWrapper.h
1 // Copyright (c) Tech Soft 3D
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #pragma once
11 
12 
13 namespace Query
14 {
15 
16  template <typename Type, typename TypeData, typename GetFunction>
18  {
19  public:
21  Type * entity,
22  GetFunction getter)
23  : entity(entity)
24  , getter(getter)
25  , valid(false)
26  {}
27 
29  ExchangePointerObject && that)
30  {
31  *this = that;
32 
33  that.valid = false;
34  that.entity = nullptr;
35  that.memset(&data, 0, sizeof(data));
36  that.getter = nullptr;
37  }
38 
39  virtual ~ExchangePointerObject()
40  {
41  if (valid)
42  getter(nullptr, &data);
43  }
44 
45  ExchangePointerObject & operator=(
46  ExchangePointerObject && that)
47  {
48  *this = that;
49 
50  that.valid = false;
51  that.entity = nullptr;
52  that.memset(&data, 0, sizeof(data));
53  that.getter = nullptr;
54 
55  return *this;
56  }
57 
58  operator Type *() const { return entity; }
59 
60  TypeData const * operator->() const { return &data; }
61  TypeData * operator->() { return &data; }
62 
63  bool IsValid() const { return valid; }
64 
65  TypeData data;
66 
67  private:
68  bool valid;
69  Type * entity;
70  GetFunction getter;
71 
72  protected:
73  void getData()
74  {
75  A3DStatus status = getter(entity, &data);
76  valid = (status == A3D_SUCCESS);
77  }
78 
79  private:
82  ExchangePointerObject & operator=(ExchangePointerObject const &) = default;
83  };
84 
85  template <typename Type, typename TypeData, typename GetFunction>
87  {
88  public:
90  Type index,
91  GetFunction getter)
92  : index(index)
93  , getter(getter)
94  , valid(false)
95  {}
96 
98  ExchangeIndexObject && that)
99  {
100  *this = that;
101 
102  that.valid = false;
103  that.index = (Type)-1;
104  that.memset(&data, 0, sizeof(data));
105  that.getter = nullptr;
106  }
107 
108  virtual ~ExchangeIndexObject()
109  {
110  if (valid)
111  getter((Type)-1, &data);
112  }
113 
114  ExchangeIndexObject & operator=(
115  ExchangeIndexObject && that)
116  {
117  *this = that;
118 
119  that.valid = false;
120  that.index = (Type)-1;
121  that.memset(&data, 0, sizeof(data));
122  that.getter = nullptr;
123 
124  return *this;
125  }
126 
127  operator Type () const { return index; }
128 
129  TypeData const * operator->() const { return &data; }
130  TypeData * operator->() { return &data; }
131 
132  bool IsValid() const { return valid; }
133 
134  TypeData data;
135 
136  private:
137  bool valid;
138  Type index;
139  GetFunction getter;
140 
141  protected:
142  void getData()
143  {
144  A3DStatus status = getter(index, &data);
145  valid = (status == A3D_SUCCESS);
146  }
147 
148  private:
151  ExchangeIndexObject & operator=(ExchangeIndexObject const &) = default;
152  };
153 
156  {
157  public:
158  DrawingModel(
159  A3DDrawingModel * entity)
160  : BaseDrawingModel(entity, A3DDrawingModelGet)
161  {
162  A3D_INITIALIZE_DATA(A3DDrawingModelData, data);
163  getData();
164  }
165  };
166 
169  {
170  public:
171  DrawingSheet(
172  A3DDrawingSheet * entity)
173  : BaseDrawingSheet(entity, A3DDrawingSheetGet)
174  {
175  A3D_INITIALIZE_DATA(A3DDrawingSheetData, data);
176  getData();
177  }
178  };
179 
181  class GraphStyle : public BaseGraphStyle
182  {
183  public:
184  GraphStyle(
185  A3DUns32 index)
186  : BaseGraphStyle(index, A3DGlobalGetGraphStyleData)
187  {
188  A3D_INITIALIZE_DATA(A3DGraphStyleData, data);
189  if (index != A3D_DEFAULT_STYLE_INDEX)
190  getData();
191  }
192  };
193 
196  {
197  public:
199  A3DDrawingSheetFormat * entity)
200  : BaseDrawingSheetFormat(entity, A3DDrawingSheetFormatGet)
201  {
202  A3D_INITIALIZE_DATA(A3DDrawingSheetFormatData, data);
203  getData();
204  }
205  };
206 
209  {
210  public:
212  A3DDrawingBlockBasic * entity)
213  : BaseDrawingBlockBasic(entity, A3DDrawingBlockBasicGet)
214  {
215  A3D_INITIALIZE_DATA(A3DDrawingBlockBasicData, data);
216  getData();
217  }
218  };
219 
222  {
223  public:
225  A3DDrawingBlockOperator * entity)
226  : BaseDrawingBlockOperator(entity, A3DDrawingBlockOperatorGet)
227  {
228  A3D_INITIALIZE_DATA(A3DDrawingBlockOperatorData, data);
229  getData();
230  }
231  };
232 
235  {
236  public:
237  DrawingCurve(
238  A3DDrawingCurve * entity)
239  : BaseDrawingCurve(entity, A3DDrawingCurveGet)
240  {
241  A3D_INITIALIZE_DATA(A3DDrawingCurveData, data);
242  getData();
243  }
244  };
245 
248  {
249  public:
251  A3DDrawingFilledArea * entity)
252  : BaseDrawingFilledArea(entity, A3DDrawingFilledAreaGet)
253  {
254  A3D_INITIALIZE_DATA(A3DDrawingFilledAreaData, data);
255  getData();
256  }
257  };
258 
261  {
262  public:
264  A3DDrawingPicture * entity)
265  : BaseDrawingPicture(entity, A3DDrawingPictureGet)
266  {
267  A3D_INITIALIZE_DATA(A3DDrawingPictureData, data);
268  getData();
269  }
270  };
271 
274  {
275  public:
277  A3DDrawingVertices * entity)
278  : BaseDrawingVertices(entity, A3DDrawingVerticesGet)
279  {
280  A3D_INITIALIZE_DATA(A3DDrawingVerticesData, data);
281  getData();
282  }
283  };
284 
287  {
288  public:
289  DrawingView(
290  A3DDrawingView * entity)
291  : BaseDrawingView(entity, A3DDrawingViewGet)
292  {
293  A3D_INITIALIZE_DATA(A3DDrawingViewData, data);
294  getData();
295  }
296  };
297 
300  {
301  public:
303  A3DDrawingClipFrame * entity)
304  : BaseDrawingClipFrame(entity, A3DDrawingClipFrameGet)
305  {
306  A3D_INITIALIZE_DATA(A3DDrawingClipFrameData, data);
307  getData();
308  }
309  };
310 
313  {
314  public:
316  A3DCrvBlend02Boundary * entity)
317  : BaseCrvBlend02Boundary(entity, A3DCrvBlend02BoundaryGet)
318  {
319  A3D_INITIALIZE_DATA(A3DCrvBlend02BoundaryData, data);
320  getData();
321  }
322  };
323 
325  class CrvCircle : public BaseCrvCircle
326  {
327  public:
328  CrvCircle(
329  A3DCrvCircle * entity)
330  : BaseCrvCircle(entity, A3DCrvCircleGet)
331  {
332  A3D_INITIALIZE_DATA(A3DCrvCircleData, data);
333  getData();
334  }
335  };
336 
339  {
340  public:
341  CrvComposite(
342  A3DCrvComposite * entity)
343  : BaseCrvComposite(entity, A3DCrvCompositeGet)
344  {
345  A3D_INITIALIZE_DATA(A3DCrvCompositeData, data);
346  getData();
347  }
348  };
349 
351  class CrvEllipse : public BaseCrvEllipse
352  {
353  public:
354  CrvEllipse(
355  A3DCrvEllipse * entity)
356  : BaseCrvEllipse(entity, A3DCrvEllipseGet)
357  {
358  A3D_INITIALIZE_DATA(A3DCrvEllipseData, data);
359  getData();
360  }
361  };
362 
364  class CrvHelix : public BaseCrvHelix
365  {
366  public:
367  CrvHelix(
368  A3DCrvHelix * entity)
369  : BaseCrvHelix(entity, A3DCrvHelixGet)
370  {
371  A3D_INITIALIZE_DATA(A3DCrvHelixData, data);
372  getData();
373  }
374  };
375 
378  {
379  public:
380  CrvHyperbola(
381  A3DCrvHyperbola * entity)
382  : BaseCrvHyperbola(entity, A3DCrvHyperbolaGet)
383  {
384  A3D_INITIALIZE_DATA(A3DCrvHyperbolaData, data);
385  getData();
386  }
387  };
388 
391  {
392  public:
394  A3DCrvIntersection * entity)
395  : BaseCrvIntersection(entity, A3DCrvIntersectionGet)
396  {
397  A3D_INITIALIZE_DATA(A3DCrvIntersectionData, data);
398  getData();
399  }
400  };
401 
403  class CrvLine : public BaseCrvLine
404  {
405  public:
406  CrvLine(
407  A3DCrvLine * entity)
408  : BaseCrvLine(entity, A3DCrvLineGet)
409  {
410  A3D_INITIALIZE_DATA(A3DCrvLineData, data);
411  getData();
412  }
413  };
414 
416  class CrvOffset : public BaseCrvOffset
417  {
418  public:
419  CrvOffset(
420  A3DCrvOffset * entity)
421  : BaseCrvOffset(entity, A3DCrvOffsetGet)
422  {
423  A3D_INITIALIZE_DATA(A3DCrvOffsetData, data);
424  getData();
425  }
426  };
427 
429  class CrvOnSurf : public BaseCrvOnSurf
430  {
431  public:
432  CrvOnSurf(
433  A3DCrvOnSurf * entity)
434  : BaseCrvOnSurf(entity, A3DCrvOnSurfGet)
435  {
436  A3D_INITIALIZE_DATA(A3DCrvOnSurfData, data);
437  getData();
438  }
439  };
440 
443  {
444  public:
445  CrvParabola(
446  A3DCrvParabola * entity)
447  : BaseCrvParabola(entity, A3DCrvParabolaGet)
448  {
449  A3D_INITIALIZE_DATA(A3DCrvParabolaData, data);
450  getData();
451  }
452  };
453 
456  {
457  public:
458  CrvPolyLine(
459  A3DCrvPolyLine * entity)
460  : BaseCrvPolyLine(entity, A3DCrvPolyLineGet)
461  {
462  A3D_INITIALIZE_DATA(A3DCrvPolyLineData, data);
463  getData();
464  }
465  };
466 
469  {
470  public:
471  CrvTransform(
472  A3DCrvTransform * entity)
473  : BaseCrvTransform(entity, A3DCrvTransformGet)
474  {
475  A3D_INITIALIZE_DATA(A3DCrvTransformData, data);
476  getData();
477  }
478  };
479 
481  class TessBase : public BaseTessBase
482  {
483  public:
484  TessBase(
485  A3DTessBase * entity)
486  : BaseTessBase(entity, A3DTessBaseGet)
487  {
488  A3D_INITIALIZE_DATA(A3DTessBaseData, data);
489  getData();
490  }
491  };
492 
494  class Tess3DWire : public BaseTess3DWire
495  {
496  public:
497  Tess3DWire(
498  A3DTess3DWire * entity)
499  : BaseTess3DWire(entity, A3DTess3DWireGet)
500  {
501  A3D_INITIALIZE_DATA(A3DTess3DWireData, data);
502  getData();
503  }
504  };
505 
507  class TessMarkup : public BaseTessMarkup
508  {
509  public:
510  TessMarkup(
511  A3DTessMarkup * entity)
512  : BaseTessMarkup(entity, A3DTessMarkupGet)
513  {
514  A3D_INITIALIZE_DATA(A3DTessMarkupData, data);
515  getData();
516  }
517  };
518 
521  {
522  public:
524  A3DRiRepresentationItem * entity)
525  : BaseRiRepresentationItem(entity, A3DRiRepresentationItemGet)
526  {
527  A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, data);
528  getData();
529  }
530  };
531 
534  {
535  public:
537  A3DUns32 index)
538  : BaseGraphHatchingPattern(index, A3DGlobalGetGraphHatchingPatternData)
539  {
540  A3D_INITIALIZE_DATA(A3DGraphHatchingPatternData, data);
541  if (index != A3D_DEFAULT_PATTERN_INDEX)
542  getData();
543  }
544  };
545 
548  {
549  public:
550  AsmModelFile(
551  A3DAsmModelFile * entity)
552  : BaseAsmModelFile(entity, A3DAsmModelFileGet)
553  {
554  A3D_INITIALIZE_DATA(A3DAsmModelFileData, data);
555  getData();
556  }
557  };
558 
561  {
562  public:
564  A3DAsmProductOccurrence * entity)
565  : BaseAsmProductOccurrence(entity, A3DAsmProductOccurrenceGet)
566  {
567  A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, data);
568  getData();
569  }
570  };
571 
574  {
575  public:
577  A3DAsmPartDefinition * entity)
578  : BaseAsmPartDefinition(entity, A3DAsmPartDefinitionGet)
579  {
580  A3D_INITIALIZE_DATA(A3DAsmPartDefinitionData, data);
581  getData();
582  }
583  };
584 
586  class RootBase : public BaseRootBase
587  {
588  public:
589  RootBase(
590  A3DRootBase * entity)
591  : BaseRootBase(entity, A3DRootBaseGet)
592  {
593  A3D_INITIALIZE_DATA(A3DRootBaseData, data);
594  getData();
595  }
596  };
597 
599  class MkpMarkup : public BaseMkpMarkup
600  {
601  public:
602  MkpMarkup(
603  A3DMkpMarkup * entity)
604  : BaseMkpMarkup(entity, A3DMkpMarkupGet)
605  {
606  A3D_INITIALIZE_DATA(A3DMkpMarkupData, data);
607  getData();
608  }
609  };
610 
613  {
614  public:
616  A3DMarkupRichText * entity)
617  : BaseMarkupRichText(entity, A3DMarkupRichTextGet)
618  {
619  A3D_INITIALIZE_DATA(A3DMarkupRichTextData, data);
620  getData();
621  }
622  };
623 
626  {
627  public:
629  A3DMarkupDefinition * entity)
630  : BaseMarkupDefinition(entity, A3DMarkupDefinitionGet)
631  {
632  A3D_INITIALIZE_DATA(A3DMarkupDefinitionData, data);
633  getData();
634  }
635  };
636 
639  {
640  public:
641  MDPosition2D(
642  A3DMDPosition2D * entity)
643  : BaseMDPosition2D(entity, A3DMDPosition2DGet)
644  {
645  A3D_INITIALIZE_DATA(A3DMDPosition2DData, data);
646  getData();
647  }
648  };
649 
652  {
653  public:
655  A3DUns32 index)
656  : BaseGraphLinePattern(index, A3DGlobalGetGraphLinePatternData)
657  {
658  A3D_INITIALIZE_DATA(A3DGraphLinePatternData, data);
659  if (index != A3D_DEFAULT_LINEPATTERN_INDEX)
660  getData();
661  }
662  };
663 
666  {
667  public:
668  GraphPicture(
669  A3DUns32 index)
670  : BaseGraphPicture(index, A3DGlobalGetGraphPictureData)
671  {
672  A3D_INITIALIZE_DATA(A3DGraphPictureData, data);
673  if (index != A3D_DEFAULT_PICTURE_INDEX)
674  getData();
675  }
676  };
677 
680  {
681  public:
683  A3DUns32 index)
684  : BaseGraphTextureDefinition(index, A3DGlobalGetGraphTextureDefinitionData)
685  {
686  A3D_INITIALIZE_DATA(A3DGraphTextureDefinitionData, data);
687  if (index != A3D_DEFAULT_TEXTURE_DEFINITION_INDEX)
688  getData();
689  }
690  };
691 
692 
694  {
695  public:
697  A3DRootBaseWithGraphics const * entity,
698  A3DMiscCascadedAttributes const * fatherAttr)
699  : entity(entity)
700  , attr(nullptr)
701  , validData(false)
702  {
703  A3D_INITIALIZE_DATA(A3DMiscCascadedAttributesData, data);
704 
705  A3DStatus status = A3DMiscCascadedAttributesCreate(&attr);
706  if (status == A3D_SUCCESS)
707  {
708  status = A3DMiscCascadedAttributesPush(attr, entity, fatherAttr);
709  if (status == A3D_SUCCESS)
710  {
711  status = A3DMiscCascadedAttributesGet(attr, &data);
712  validData = (status == A3D_SUCCESS);
713  }
714  }
715  }
716 
718  {
719  if (validData)
720  A3DMiscCascadedAttributesGet(nullptr, &data);
721  if (attr)
722  A3DMiscCascadedAttributesDelete(attr);
723  }
724 
725  operator A3DMiscCascadedAttributes *() const { return attr; }
726 
727  A3DMiscCascadedAttributesData const * operator->() const { return &data; }
728  A3DMiscCascadedAttributesData * operator->() { return &data; }
729 
730  bool IsValid() const { return attr != nullptr && validData; }
731 
732  A3DRootBaseWithGraphics const * entity;
733  A3DMiscCascadedAttributes * attr;
734  bool validData;
735  A3DMiscCascadedAttributesData data;
736  };
737 
738 }
Definition: ExchangeWrapper.h:195
Definition: ExchangeWrapper.h:312
Definition: ExchangeWrapper.h:679
Definition: ExchangeWrapper.h:520
Definition: ExchangeWrapper.h:299
Definition: ExchangeWrapper.h:181
Definition: ExchangeWrapper.h:17
Definition: ExchangeWrapper.h:547
Definition: ExchangeWrapper.h:612
Definition: ExchangeWrapper.h:377
Definition: ExchangeWrapper.h:247
Definition: ExchangeWrapper.h:364
Definition: ExchangeWrapper.h:286
Definition: ExchangeWrapper.h:325
Definition: ExchangeWrapper.h:442
Definition: ExchangeWrapper.h:338
Definition: ExchangeWrapper.h:390
Definition: ExchangeWrapper.h:625
Definition: ExchangeWrapper.h:429
Definition: ExchangeWrapper.h:693
Definition: ExchangeWrapper.h:586
Definition: ExchangeWrapper.h:168
Definition: ExchangeWrapper.h:665
Definition: ExchangeWrapper.h:573
Definition: ExchangeWrapper.h:273
Definition: ExchangeWrapper.h:234
Definition: ExchangeWrapper.h:86
Definition: ExchangeWrapper.h:533
Definition: ExchangeWrapper.h:403
Definition: ExchangeWrapper.h:651
Definition: ExchangeWrapper.h:155
Definition: ExchangeWrapper.h:260
Definition: ExchangeWrapper.h:468
Definition: ExchangeWrapper.h:560
Definition: ExchangeWrapper.h:351
Definition: ExchangeWrapper.h:221
Definition: ExchangeWrapper.h:507
Definition: ExchangeWrapper.h:455
Definition: ExchangeWrapper.h:208
Definition: ExchangeWrapper.h:494
Definition: ExchangeWrapper.h:599
Definition: ExchangeWrapper.h:638
Definition: ExchangeWrapper.h:416
Definition: ExchangeWrapper.h:481