0024057: Eliminate compiler warning C4100 in MSVC++ with warning level 4
[occt.git] / src / IGESAppli / IGESAppli_GeneralModule.cxx
1 // Copyright (c) 1999-2012 OPEN CASCADE SAS
2 //
3 // The content of this file is subject to the Open CASCADE Technology Public
4 // License Version 6.5 (the "License"). You may not use the content of this file
5 // except in compliance with the License. Please obtain a copy of the License
6 // at http://www.opencascade.org and read it completely before using this file.
7 //
8 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
9 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
10 //
11 // The Original Code and all software distributed under the License is
12 // distributed on an "AS IS" basis, without warranty of any kind, and the
13 // Initial Developer hereby disclaims all such warranties, including without
14 // limitation, any warranties of merchantability, fitness for a particular
15 // purpose or non-infringement. Please see the License for the specific terms
16 // and conditions governing the rights and limitations under the License.
17
18 #include <IGESAppli_GeneralModule.ixx>
19 #include <Interface_Macros.hxx>
20 #include <Interface_Category.hxx>
21
22 #include <IGESAppli_DrilledHole.hxx>
23 #include <IGESAppli_ElementResults.hxx>
24 #include <IGESAppli_FiniteElement.hxx>
25 #include <IGESAppli_Flow.hxx>
26 #include <IGESAppli_FlowLineSpec.hxx>
27 #include <IGESAppli_LevelFunction.hxx>
28 #include <IGESAppli_LevelToPWBLayerMap.hxx>
29 #include <IGESAppli_LineWidening.hxx>
30 #include <IGESAppli_NodalConstraint.hxx>
31 #include <IGESAppli_NodalDisplAndRot.hxx>
32 #include <IGESAppli_NodalResults.hxx>
33 #include <IGESAppli_Node.hxx>
34 #include <IGESAppli_PWBArtworkStackup.hxx>
35 #include <IGESAppli_PWBDrilledHole.hxx>
36 #include <IGESAppli_PartNumber.hxx>
37 #include <IGESAppli_PinNumber.hxx>
38 #include <IGESAppli_PipingFlow.hxx>
39 #include <IGESAppli_ReferenceDesignator.hxx>
40 #include <IGESAppli_RegionRestriction.hxx>
41
42 #include <IGESAppli_ToolDrilledHole.hxx>
43 #include <IGESAppli_ToolElementResults.hxx>
44 #include <IGESAppli_ToolFiniteElement.hxx>
45 #include <IGESAppli_ToolFlow.hxx>
46 #include <IGESAppli_ToolFlowLineSpec.hxx>
47 #include <IGESAppli_ToolLevelFunction.hxx>
48 #include <IGESAppli_ToolLevelToPWBLayerMap.hxx>
49 #include <IGESAppli_ToolLineWidening.hxx>
50 #include <IGESAppli_ToolNodalConstraint.hxx>
51 #include <IGESAppli_ToolNodalDisplAndRot.hxx>
52 #include <IGESAppli_ToolNodalResults.hxx>
53 #include <IGESAppli_ToolNode.hxx>
54 #include <IGESAppli_ToolPWBArtworkStackup.hxx>
55 #include <IGESAppli_ToolPWBDrilledHole.hxx>
56 #include <IGESAppli_ToolPartNumber.hxx>
57 #include <IGESAppli_ToolPinNumber.hxx>
58 #include <IGESAppli_ToolPipingFlow.hxx>
59 #include <IGESAppli_ToolReferenceDesignator.hxx>
60 #include <IGESAppli_ToolRegionRestriction.hxx>
61
62
63
64 //  Each Module is attached to a Protocol : it must interprete Case Numbers
65 //  (arguments <CN> of various methods) in accordance to values returned by
66 //  the method TypeNumber from this Protocol
67
68
69 IGESAppli_GeneralModule::IGESAppli_GeneralModule ()    {  }
70
71
72     void  IGESAppli_GeneralModule::OwnSharedCase
73   (const Standard_Integer CN, const Handle(IGESData_IGESEntity)& ent,
74    Interface_EntityIterator& iter) const 
75 {
76   switch (CN) {
77     case  1 : {
78       DeclareAndCast(IGESAppli_DrilledHole,anent,ent);
79       if (anent.IsNull()) return;
80       IGESAppli_ToolDrilledHole tool;
81       tool.OwnShared(anent,iter);
82     }
83       break;
84     case  2 : {
85       DeclareAndCast(IGESAppli_ElementResults,anent,ent);
86       if (anent.IsNull()) return;
87       IGESAppli_ToolElementResults tool;
88       tool.OwnShared(anent,iter);
89     }
90       break;
91     case  3 : {
92       DeclareAndCast(IGESAppli_FiniteElement,anent,ent);
93       if (anent.IsNull()) return;
94       IGESAppli_ToolFiniteElement tool;
95       tool.OwnShared(anent,iter);
96     }
97       break;
98     case  4 : {
99       DeclareAndCast(IGESAppli_Flow,anent,ent);
100       if (anent.IsNull()) return;
101       IGESAppli_ToolFlow tool;
102       tool.OwnShared(anent,iter);
103     }
104       break;
105     case  5 : {
106       DeclareAndCast(IGESAppli_FlowLineSpec,anent,ent);
107       if (anent.IsNull()) return;
108       IGESAppli_ToolFlowLineSpec tool;
109       tool.OwnShared(anent,iter);
110     }
111       break;
112     case  6 : {
113       DeclareAndCast(IGESAppli_LevelFunction,anent,ent);
114       if (anent.IsNull()) return;
115       IGESAppli_ToolLevelFunction tool;
116       tool.OwnShared(anent,iter);
117     }
118       break;
119     case  7 : {
120       DeclareAndCast(IGESAppli_LevelToPWBLayerMap,anent,ent);
121       if (anent.IsNull()) return;
122       IGESAppli_ToolLevelToPWBLayerMap tool;
123       tool.OwnShared(anent,iter);
124     }
125       break;
126     case  8 : {
127       DeclareAndCast(IGESAppli_LineWidening,anent,ent);
128       if (anent.IsNull()) return;
129       IGESAppli_ToolLineWidening tool;
130       tool.OwnShared(anent,iter);
131     }
132       break;
133     case  9 : {
134       DeclareAndCast(IGESAppli_NodalConstraint,anent,ent);
135       if (anent.IsNull()) return;
136       IGESAppli_ToolNodalConstraint tool;
137       tool.OwnShared(anent,iter);
138     }
139       break;
140     case 10 : {
141       DeclareAndCast(IGESAppli_NodalDisplAndRot,anent,ent);
142       if (anent.IsNull()) return;
143       IGESAppli_ToolNodalDisplAndRot tool;
144       tool.OwnShared(anent,iter);
145     }
146       break;
147     case 11 : {
148       DeclareAndCast(IGESAppli_NodalResults,anent,ent);
149       if (anent.IsNull()) return;
150       IGESAppli_ToolNodalResults tool;
151       tool.OwnShared(anent,iter);
152     }
153       break;
154     case 12 : {
155       DeclareAndCast(IGESAppli_Node,anent,ent);
156       if (anent.IsNull()) return;
157       IGESAppli_ToolNode tool;
158       tool.OwnShared(anent,iter);
159     }
160       break;
161     case 13 : {
162       DeclareAndCast(IGESAppli_PWBArtworkStackup,anent,ent);
163       if (anent.IsNull()) return;
164       IGESAppli_ToolPWBArtworkStackup tool;
165       tool.OwnShared(anent,iter);
166     }
167       break;
168     case 14 : {
169       DeclareAndCast(IGESAppli_PWBDrilledHole,anent,ent);
170       if (anent.IsNull()) return;
171       IGESAppli_ToolPWBDrilledHole tool;
172       tool.OwnShared(anent,iter);
173     }
174       break;
175     case 15 : {
176       DeclareAndCast(IGESAppli_PartNumber,anent,ent);
177       if (anent.IsNull()) return;
178       IGESAppli_ToolPartNumber tool;
179       tool.OwnShared(anent,iter);
180     }
181       break;
182     case 16 : {
183       DeclareAndCast(IGESAppli_PinNumber,anent,ent);
184       if (anent.IsNull()) return;
185       IGESAppli_ToolPinNumber tool;
186       tool.OwnShared(anent,iter);
187     }
188       break;
189     case 17 : {
190       DeclareAndCast(IGESAppli_PipingFlow,anent,ent);
191       if (anent.IsNull()) return;
192       IGESAppli_ToolPipingFlow tool;
193       tool.OwnShared(anent,iter);
194     }
195       break;
196     case 18 : {
197       DeclareAndCast(IGESAppli_ReferenceDesignator,anent,ent);
198       if (anent.IsNull()) return;
199       IGESAppli_ToolReferenceDesignator tool;
200       tool.OwnShared(anent,iter);
201     }
202       break;
203     case 19 : {
204       DeclareAndCast(IGESAppli_RegionRestriction,anent,ent);
205       if (anent.IsNull()) return;
206       IGESAppli_ToolRegionRestriction tool;
207       tool.OwnShared(anent,iter);
208     }
209       break;
210     default : break;
211   }
212 }
213
214
215     IGESData_DirChecker  IGESAppli_GeneralModule::DirChecker
216   (const Standard_Integer CN, const Handle(IGESData_IGESEntity)& ent) const 
217 {
218   switch (CN) {
219     case  1 : {
220       DeclareAndCast(IGESAppli_DrilledHole,anent,ent);
221       if (anent.IsNull()) break;
222       IGESAppli_ToolDrilledHole tool;
223       return tool.DirChecker(anent);
224     }
225     case  2 : {
226       DeclareAndCast(IGESAppli_ElementResults,anent,ent);
227       if (anent.IsNull()) break;
228       IGESAppli_ToolElementResults tool;
229       return tool.DirChecker(anent);
230     }
231     case  3 : {
232       DeclareAndCast(IGESAppli_FiniteElement,anent,ent);
233       if (anent.IsNull()) break;
234       IGESAppli_ToolFiniteElement tool;
235       return tool.DirChecker(anent);
236     }
237     case  4 : {
238       DeclareAndCast(IGESAppli_Flow,anent,ent);
239       if (anent.IsNull()) break;
240       IGESAppli_ToolFlow tool;
241       return tool.DirChecker(anent);
242     }
243     case  5 : {
244       DeclareAndCast(IGESAppli_FlowLineSpec,anent,ent);
245       if (anent.IsNull()) break;
246       IGESAppli_ToolFlowLineSpec tool;
247       return tool.DirChecker(anent);
248     }
249     case  6 : {
250       DeclareAndCast(IGESAppli_LevelFunction,anent,ent);
251       if (anent.IsNull()) break;
252       IGESAppli_ToolLevelFunction tool;
253       return tool.DirChecker(anent);
254     }
255     case  7 : {
256       DeclareAndCast(IGESAppli_LevelToPWBLayerMap,anent,ent);
257       if (anent.IsNull()) break;
258       IGESAppli_ToolLevelToPWBLayerMap tool;
259       return tool.DirChecker(anent);
260     }
261     case  8 : {
262       DeclareAndCast(IGESAppli_LineWidening,anent,ent);
263       if (anent.IsNull()) break;
264       IGESAppli_ToolLineWidening tool;
265       return tool.DirChecker(anent);
266     }
267     case  9 : {
268       DeclareAndCast(IGESAppli_NodalConstraint,anent,ent);
269       if (anent.IsNull()) break;
270       IGESAppli_ToolNodalConstraint tool;
271       return tool.DirChecker(anent);
272     }
273     case 10 : {
274       DeclareAndCast(IGESAppli_NodalDisplAndRot,anent,ent);
275       if (anent.IsNull()) break;
276       IGESAppli_ToolNodalDisplAndRot tool;
277       return tool.DirChecker(anent);
278     }
279     case 11 : {
280       DeclareAndCast(IGESAppli_NodalResults,anent,ent);
281       if (anent.IsNull()) break;
282       IGESAppli_ToolNodalResults tool;
283       return tool.DirChecker(anent);
284     }
285     case 12 : {
286       DeclareAndCast(IGESAppli_Node,anent,ent);
287       if (anent.IsNull()) break;
288       IGESAppli_ToolNode tool;
289       return tool.DirChecker(anent);
290     }
291     case 13 : {
292       DeclareAndCast(IGESAppli_PWBArtworkStackup,anent,ent);
293       if (anent.IsNull()) break;
294       IGESAppli_ToolPWBArtworkStackup tool;
295       return tool.DirChecker(anent);
296     }
297     case 14 : {
298       DeclareAndCast(IGESAppli_PWBDrilledHole,anent,ent);
299       if (anent.IsNull()) break;
300       IGESAppli_ToolPWBDrilledHole tool;
301       return tool.DirChecker(anent);
302     }
303     case 15 : {
304       DeclareAndCast(IGESAppli_PartNumber,anent,ent);
305       if (anent.IsNull()) break;
306       IGESAppli_ToolPartNumber tool;
307       return tool.DirChecker(anent);
308     }
309     case 16 : {
310       DeclareAndCast(IGESAppli_PinNumber,anent,ent);
311       if (anent.IsNull()) break;
312       IGESAppli_ToolPinNumber tool;
313       return tool.DirChecker(anent);
314     }
315     case 17 : {
316       DeclareAndCast(IGESAppli_PipingFlow,anent,ent);
317       if (anent.IsNull()) break;
318       IGESAppli_ToolPipingFlow tool;
319       return tool.DirChecker(anent);
320     }
321     case 18 : {
322       DeclareAndCast(IGESAppli_ReferenceDesignator,anent,ent);
323       if (anent.IsNull()) break;
324       IGESAppli_ToolReferenceDesignator tool;
325       return tool.DirChecker(anent);
326     }
327     case 19 : {
328       DeclareAndCast(IGESAppli_RegionRestriction,anent,ent);
329       if (anent.IsNull()) break;
330       IGESAppli_ToolRegionRestriction tool;
331       return tool.DirChecker(anent);
332     }
333     default : break;
334   }
335   return IGESData_DirChecker();    // by default, no specific criterium
336 }
337
338
339     void  IGESAppli_GeneralModule::OwnCheckCase
340   (const Standard_Integer CN, const Handle(IGESData_IGESEntity)& ent,
341    const Interface_ShareTool& shares, Handle(Interface_Check)& ach) const 
342 {
343   switch (CN) {
344     case  1 : {
345       DeclareAndCast(IGESAppli_DrilledHole,anent,ent);
346       if (anent.IsNull()) return;
347       IGESAppli_ToolDrilledHole tool;
348       tool.OwnCheck(anent,shares,ach);
349     }
350       break;
351     case  2 : {
352       DeclareAndCast(IGESAppli_ElementResults,anent,ent);
353       if (anent.IsNull()) return;
354       IGESAppli_ToolElementResults tool;
355       tool.OwnCheck(anent,shares,ach);
356     }
357       break;
358     case  3 : {
359       DeclareAndCast(IGESAppli_FiniteElement,anent,ent);
360       if (anent.IsNull()) return;
361       IGESAppli_ToolFiniteElement tool;
362       tool.OwnCheck(anent,shares,ach);
363     }
364       break;
365     case  4 : {
366       DeclareAndCast(IGESAppli_Flow,anent,ent);
367       if (anent.IsNull()) return;
368       IGESAppli_ToolFlow tool;
369       tool.OwnCheck(anent,shares,ach);
370     }
371       break;
372     case  5 : {
373       DeclareAndCast(IGESAppli_FlowLineSpec,anent,ent);
374       if (anent.IsNull()) return;
375       IGESAppli_ToolFlowLineSpec tool;
376       tool.OwnCheck(anent,shares,ach);
377     }
378       break;
379     case  6 : {
380       DeclareAndCast(IGESAppli_LevelFunction,anent,ent);
381       if (anent.IsNull()) return;
382       IGESAppli_ToolLevelFunction tool;
383       tool.OwnCheck(anent,shares,ach);
384     }
385       break;
386     case  7 : {
387       DeclareAndCast(IGESAppli_LevelToPWBLayerMap,anent,ent);
388       if (anent.IsNull()) return;
389       IGESAppli_ToolLevelToPWBLayerMap tool;
390       tool.OwnCheck(anent,shares,ach);
391     }
392       break;
393     case  8 : {
394       DeclareAndCast(IGESAppli_LineWidening,anent,ent);
395       if (anent.IsNull()) return;
396       IGESAppli_ToolLineWidening tool;
397       tool.OwnCheck(anent,shares,ach);
398     }
399       break;
400     case  9 : {
401       DeclareAndCast(IGESAppli_NodalConstraint,anent,ent);
402       if (anent.IsNull()) return;
403       IGESAppli_ToolNodalConstraint tool;
404       tool.OwnCheck(anent,shares,ach);
405     }
406       break;
407     case 10 : {
408       DeclareAndCast(IGESAppli_NodalDisplAndRot,anent,ent);
409       if (anent.IsNull()) return;
410       IGESAppli_ToolNodalDisplAndRot tool;
411       tool.OwnCheck(anent,shares,ach);
412     }
413       break;
414     case 11 : {
415       DeclareAndCast(IGESAppli_NodalResults,anent,ent);
416       if (anent.IsNull()) return;
417       IGESAppli_ToolNodalResults tool;
418       tool.OwnCheck(anent,shares,ach);
419     }
420       break;
421     case 12 : {
422       DeclareAndCast(IGESAppli_Node,anent,ent);
423       if (anent.IsNull()) return;
424       IGESAppli_ToolNode tool;
425       tool.OwnCheck(anent,shares,ach);
426     }
427       break;
428     case 13 : {
429       DeclareAndCast(IGESAppli_PWBArtworkStackup,anent,ent);
430       if (anent.IsNull()) return;
431       IGESAppli_ToolPWBArtworkStackup tool;
432       tool.OwnCheck(anent,shares,ach);
433     }
434       break;
435     case 14 : {
436       DeclareAndCast(IGESAppli_PWBDrilledHole,anent,ent);
437       if (anent.IsNull()) return;
438       IGESAppli_ToolPWBDrilledHole tool;
439       tool.OwnCheck(anent,shares,ach);
440     }
441       break;
442     case 15 : {
443       DeclareAndCast(IGESAppli_PartNumber,anent,ent);
444       if (anent.IsNull()) return;
445       IGESAppli_ToolPartNumber tool;
446       tool.OwnCheck(anent,shares,ach);
447     }
448       break;
449     case 16 : {
450       DeclareAndCast(IGESAppli_PinNumber,anent,ent);
451       if (anent.IsNull()) return;
452       IGESAppli_ToolPinNumber tool;
453       tool.OwnCheck(anent,shares,ach);
454     }
455       break;
456     case 17 : {
457       DeclareAndCast(IGESAppli_PipingFlow,anent,ent);
458       if (anent.IsNull()) return;
459       IGESAppli_ToolPipingFlow tool;
460       tool.OwnCheck(anent,shares,ach);
461     }
462       break;
463     case 18 : {
464       DeclareAndCast(IGESAppli_ReferenceDesignator,anent,ent);
465       if (anent.IsNull()) return;
466       IGESAppli_ToolReferenceDesignator tool;
467       tool.OwnCheck(anent,shares,ach);
468     }
469       break;
470     case 19 : {
471       DeclareAndCast(IGESAppli_RegionRestriction,anent,ent);
472       if (anent.IsNull()) return;
473       IGESAppli_ToolRegionRestriction tool;
474       tool.OwnCheck(anent,shares,ach);
475     }
476       break;
477     default : break;
478   }
479 }
480
481     Standard_Boolean  IGESAppli_GeneralModule::NewVoid
482   (const Standard_Integer CN, Handle(Standard_Transient)& ent) const 
483 {
484   switch (CN) {
485     case  1 : ent = new IGESAppli_DrilledHole;  break;
486     case  2 : ent = new IGESAppli_ElementResults;       break;
487     case  3 : ent = new IGESAppli_FiniteElement;        break;
488     case  4 : ent = new IGESAppli_Flow; break;
489     case  5 : ent = new IGESAppli_FlowLineSpec; break;
490     case  6 : ent = new IGESAppli_LevelFunction;        break;
491     case  7 : ent = new IGESAppli_LevelToPWBLayerMap;   break;
492     case  8 : ent = new IGESAppli_LineWidening; break;
493     case  9 : ent = new IGESAppli_NodalConstraint;      break;
494     case 10 : ent = new IGESAppli_NodalDisplAndRot;     break;
495     case 11 : ent = new IGESAppli_NodalResults; break;
496     case 12 : ent = new IGESAppli_Node; break;
497     case 13 : ent = new IGESAppli_PWBArtworkStackup;    break;
498     case 14 : ent = new IGESAppli_PWBDrilledHole;       break;
499     case 15 : ent = new IGESAppli_PartNumber;   break;
500     case 16 : ent = new IGESAppli_PinNumber;    break;
501     case 17 : ent = new IGESAppli_PipingFlow;   break;
502     case 18 : ent = new IGESAppli_ReferenceDesignator;  break;
503     case 19 : ent = new IGESAppli_RegionRestriction;    break;
504     default : return Standard_False;    // by default, Failure on Recognize
505   }
506   return Standard_True;
507 }
508
509     void  IGESAppli_GeneralModule::OwnCopyCase
510   (const Standard_Integer CN,
511    const Handle(IGESData_IGESEntity)& entfrom,
512    const Handle(IGESData_IGESEntity)& entto,
513    Interface_CopyTool& TC) const 
514 {
515   switch (CN) {
516     case  1 : {
517       DeclareAndCast(IGESAppli_DrilledHole,enfr,entfrom);
518       DeclareAndCast(IGESAppli_DrilledHole,ento,entto);
519       IGESAppli_ToolDrilledHole tool;
520       tool.OwnCopy(enfr,ento,TC);
521     }
522       break;
523     case  2 : {
524       DeclareAndCast(IGESAppli_ElementResults,enfr,entfrom);
525       DeclareAndCast(IGESAppli_ElementResults,ento,entto);
526       IGESAppli_ToolElementResults tool;
527       tool.OwnCopy(enfr,ento,TC);
528     }
529       break;
530     case  3 : {
531       DeclareAndCast(IGESAppli_FiniteElement,enfr,entfrom);
532       DeclareAndCast(IGESAppli_FiniteElement,ento,entto);
533       IGESAppli_ToolFiniteElement tool;
534       tool.OwnCopy(enfr,ento,TC);
535     }
536       break;
537     case  4 : {
538       DeclareAndCast(IGESAppli_Flow,enfr,entfrom);
539       DeclareAndCast(IGESAppli_Flow,ento,entto);
540       IGESAppli_ToolFlow tool;
541       tool.OwnCopy(enfr,ento,TC);
542     }
543       break;
544     case  5 : {
545       DeclareAndCast(IGESAppli_FlowLineSpec,enfr,entfrom);
546       DeclareAndCast(IGESAppli_FlowLineSpec,ento,entto);
547       IGESAppli_ToolFlowLineSpec tool;
548       tool.OwnCopy(enfr,ento,TC);
549     }
550       break;
551     case  6 : {
552       DeclareAndCast(IGESAppli_LevelFunction,enfr,entfrom);
553       DeclareAndCast(IGESAppli_LevelFunction,ento,entto);
554       IGESAppli_ToolLevelFunction tool;
555       tool.OwnCopy(enfr,ento,TC);
556     }
557       break;
558     case  7 : {
559       DeclareAndCast(IGESAppli_LevelToPWBLayerMap,enfr,entfrom);
560       DeclareAndCast(IGESAppli_LevelToPWBLayerMap,ento,entto);
561       IGESAppli_ToolLevelToPWBLayerMap tool;
562       tool.OwnCopy(enfr,ento,TC);
563     }
564       break;
565     case  8 : {
566       DeclareAndCast(IGESAppli_LineWidening,enfr,entfrom);
567       DeclareAndCast(IGESAppli_LineWidening,ento,entto);
568       IGESAppli_ToolLineWidening tool;
569       tool.OwnCopy(enfr,ento,TC);
570     }
571       break;
572     case  9 : {
573       DeclareAndCast(IGESAppli_NodalConstraint,enfr,entfrom);
574       DeclareAndCast(IGESAppli_NodalConstraint,ento,entto);
575       IGESAppli_ToolNodalConstraint tool;
576       tool.OwnCopy(enfr,ento,TC);
577     }
578       break;
579     case 10 : {
580       DeclareAndCast(IGESAppli_NodalDisplAndRot,enfr,entfrom);
581       DeclareAndCast(IGESAppli_NodalDisplAndRot,ento,entto);
582       IGESAppli_ToolNodalDisplAndRot tool;
583       tool.OwnCopy(enfr,ento,TC);
584     }
585       break;
586     case 11 : {
587       DeclareAndCast(IGESAppli_NodalResults,enfr,entfrom);
588       DeclareAndCast(IGESAppli_NodalResults,ento,entto);
589       IGESAppli_ToolNodalResults tool;
590       tool.OwnCopy(enfr,ento,TC);
591     }
592       break;
593     case 12 : {
594       DeclareAndCast(IGESAppli_Node,enfr,entfrom);
595       DeclareAndCast(IGESAppli_Node,ento,entto);
596       IGESAppli_ToolNode tool;
597       tool.OwnCopy(enfr,ento,TC);
598     }
599       break;
600     case 13 : {
601       DeclareAndCast(IGESAppli_PWBArtworkStackup,enfr,entfrom);
602       DeclareAndCast(IGESAppli_PWBArtworkStackup,ento,entto);
603       IGESAppli_ToolPWBArtworkStackup tool;
604       tool.OwnCopy(enfr,ento,TC);
605     }
606       break;
607     case 14 : {
608       DeclareAndCast(IGESAppli_PWBDrilledHole,enfr,entfrom);
609       DeclareAndCast(IGESAppli_PWBDrilledHole,ento,entto);
610       IGESAppli_ToolPWBDrilledHole tool;
611       tool.OwnCopy(enfr,ento,TC);
612     }
613       break;
614     case 15 : {
615       DeclareAndCast(IGESAppli_PartNumber,enfr,entfrom);
616       DeclareAndCast(IGESAppli_PartNumber,ento,entto);
617       IGESAppli_ToolPartNumber tool;
618       tool.OwnCopy(enfr,ento,TC);
619     }
620       break;
621     case 16 : {
622       DeclareAndCast(IGESAppli_PinNumber,enfr,entfrom);
623       DeclareAndCast(IGESAppli_PinNumber,ento,entto);
624       IGESAppli_ToolPinNumber tool;
625       tool.OwnCopy(enfr,ento,TC);
626     }
627       break;
628     case 17 : {
629       DeclareAndCast(IGESAppli_PipingFlow,enfr,entfrom);
630       DeclareAndCast(IGESAppli_PipingFlow,ento,entto);
631       IGESAppli_ToolPipingFlow tool;
632       tool.OwnCopy(enfr,ento,TC);
633     }
634       break;
635     case 18 : {
636       DeclareAndCast(IGESAppli_ReferenceDesignator,enfr,entfrom);
637       DeclareAndCast(IGESAppli_ReferenceDesignator,ento,entto);
638       IGESAppli_ToolReferenceDesignator tool;
639       tool.OwnCopy(enfr,ento,TC);
640     }
641       break;
642     case 19 : {
643       DeclareAndCast(IGESAppli_RegionRestriction,enfr,entfrom);
644       DeclareAndCast(IGESAppli_RegionRestriction,ento,entto);
645       IGESAppli_ToolRegionRestriction tool;
646       tool.OwnCopy(enfr,ento,TC);
647     }
648       break;
649     default : break;
650   }
651 }
652
653
654     Standard_Integer  IGESAppli_GeneralModule::CategoryNumber
655   (const Standard_Integer CN, const Handle(Standard_Transient)& /*ent*/,
656    const Interface_ShareTool& ) const
657 {
658   if (CN == 4 || CN == 5 || CN == 17) return Interface_Category::Number("Piping");
659   if (CN == 2 || CN == 3 || (CN >= 9 && CN <= 12)) return Interface_Category::Number("FEA");
660   return Interface_Category::Number("Professional");
661 }