libsurf
Programmer's Documentation

step_ap203.h (r6227/r5337)
1 
2 /* Copyright (C) 2015 David Eller <david@larosterna.com>
3  *
4  * Commercial License Usage
5  * Licensees holding valid commercial licenses may use this file in accordance
6  * with the terms contained in their respective non-exclusive license agreement.
7  * For further information contact david@larosterna.com .
8  *
9  * GNU General Public License Usage
10  * Alternatively, this file may be used under the terms of the GNU General
11  * Public License version 3.0 as published by the Free Software Foundation and
12  * appearing in the file gpl.txt included in the packaging of this file.
13  */
14 
15 
16 #ifndef SURF_AP203_H
17 #define SURF_AP203_H
18 
19 // automatically created by surf/tools/fedex.py -- do not edit
20 
21 #include "step.h"
22 #include "stepentity.h"
23 #include <cassert>
24 
26 {
27  public:
28  typedef enum {
29  ahead,
30  behind } Code;
31  public:
32  bool read(StepFileLine & line) {
33  int iv = 0;
34  bool ok = StepEnum::read(line, 2, stringrep, iv);
35  value = (StepAheadOrBehind::Code) iv;
36  return ok;
37  }
38  void write(std::ostream & os) const {
39  int i = (int) value;
40  assert(i < 2);
41  os << stringrep[i];
42  }
43  bool operator== (const StepAheadOrBehind & a) const
44  {return value == a.value;}
45  bool operator!= (const StepAheadOrBehind & a) const
46  {return value != a.value;}
47  bool operator== (const StepAheadOrBehind::Code & a) const
48  {return value == a;}
49  bool operator!= (const StepAheadOrBehind::Code & a) const
50  {return value != a;}
51  public:
52  StepAheadOrBehind::Code value;
53  private:
54  static const char *stringrep[];
55 };
56 
58 {
59  public:
60  enum Code {
61  product_definition_formation,
62  product_definition,
63  configuration_effectivity,
64  configuration_item,
65  security_classification,
66  change_request,
67  change,
68  start_request,
69  start_work,
70  certification,
71  contract };
72  public:
74  bool read(StepFileLine & line) {
75  bool ok = StepSelect::read(line, 11, stringrep);
76  if (ok and keyIndex >= 0)
77  value = (StepApprovedItem::Code) keyIndex;
78  return (type != NotSet);
79  }
80  void write(std::ostream & os) const {
81  StepSelect::write(os, stringrep);
82  }
83  public:
84  StepApprovedItem::Code value;
85  private:
86  static const char *stringrep[];
87 };
88 
90 {
91  public:
92  enum Code {
93  axis2_placement_2d,
94  axis2_placement_3d };
95  public:
97  bool read(StepFileLine & line) {
98  bool ok = StepSelect::read(line, 2, stringrep);
99  if (ok and keyIndex >= 0)
100  value = (StepAxis2Placement::Code) keyIndex;
101  return (type != NotSet);
102  }
103  void write(std::ostream & os) const {
104  StepSelect::write(os, stringrep);
105  }
106  public:
107  StepAxis2Placement::Code value;
108  private:
109  static const char *stringrep[];
110 };
111 
113 {
114  public:
115  typedef enum {
116  polyline_form,
117  circular_arc,
118  elliptic_arc,
119  parabolic_arc,
120  hyperbolic_arc,
121  unspecified } Code;
122  public:
123  bool read(StepFileLine & line) {
124  int iv = 0;
125  bool ok = StepEnum::read(line, 6, stringrep, iv);
126  value = (StepBSplineCurveForm::Code) iv;
127  return ok;
128  }
129  void write(std::ostream & os) const {
130  int i = (int) value;
131  assert(i < 6);
132  os << stringrep[i];
133  }
134  bool operator== (const StepBSplineCurveForm & a) const
135  {return value == a.value;}
136  bool operator!= (const StepBSplineCurveForm & a) const
137  {return value != a.value;}
138  bool operator== (const StepBSplineCurveForm::Code & a) const
139  {return value == a;}
140  bool operator!= (const StepBSplineCurveForm::Code & a) const
141  {return value != a;}
142  public:
143  StepBSplineCurveForm::Code value;
144  private:
145  static const char *stringrep[];
146 };
147 
149 {
150  public:
151  typedef enum {
152  plane_surf,
153  cylindrical_surf,
154  conical_surf,
155  spherical_surf,
156  toroidal_surf,
157  surf_of_revolution,
158  ruled_surf,
159  generalised_cone,
160  quadric_surf,
161  surf_of_linear_extrusion,
162  unspecified } Code;
163  public:
164  bool read(StepFileLine & line) {
165  int iv = 0;
166  bool ok = StepEnum::read(line, 11, stringrep, iv);
167  value = (StepBSplineSurfaceForm::Code) iv;
168  return ok;
169  }
170  void write(std::ostream & os) const {
171  int i = (int) value;
172  assert(i < 11);
173  os << stringrep[i];
174  }
175  bool operator== (const StepBSplineSurfaceForm & a) const
176  {return value == a.value;}
177  bool operator!= (const StepBSplineSurfaceForm & a) const
178  {return value != a.value;}
179  bool operator== (const StepBSplineSurfaceForm::Code & a) const
180  {return value == a;}
181  bool operator!= (const StepBSplineSurfaceForm::Code & a) const
182  {return value != a;}
183  public:
184  StepBSplineSurfaceForm::Code value;
185  private:
186  static const char *stringrep[];
187 };
188 
190 {
191  public:
192  enum Code {
193  solid_model };
194  public:
196  bool read(StepFileLine & line) {
197  bool ok = StepSelect::read(line, 1, stringrep);
198  if (ok and keyIndex >= 0)
199  value = (StepBooleanOperand::Code) keyIndex;
200  return (type != NotSet);
201  }
202  void write(std::ostream & os) const {
203  StepSelect::write(os, stringrep);
204  }
205  public:
206  StepBooleanOperand::Code value;
207  private:
208  static const char *stringrep[];
209 };
210 
212 {
213  public:
214  enum Code {
215  supplied_part_relationship };
216  public:
217  StepCertifiedItem() : StepSelect() {}
218  bool read(StepFileLine & line) {
219  bool ok = StepSelect::read(line, 1, stringrep);
220  if (ok and keyIndex >= 0)
221  value = (StepCertifiedItem::Code) keyIndex;
222  return (type != NotSet);
223  }
224  void write(std::ostream & os) const {
225  StepSelect::write(os, stringrep);
226  }
227  public:
228  StepCertifiedItem::Code value;
229  private:
230  static const char *stringrep[];
231 };
232 
234 {
235  public:
236  enum Code {
237  product_definition_formation };
238  public:
240  bool read(StepFileLine & line) {
241  bool ok = StepSelect::read(line, 1, stringrep);
242  if (ok and keyIndex >= 0)
243  value = (StepChangeRequestItem::Code) keyIndex;
244  return (type != NotSet);
245  }
246  void write(std::ostream & os) const {
247  StepSelect::write(os, stringrep);
248  }
249  public:
250  StepChangeRequestItem::Code value;
251  private:
252  static const char *stringrep[];
253 };
254 
256 {
257  public:
258  enum Code {
259  characterized_product_definition,
260  shape_definition };
261  public:
263  bool read(StepFileLine & line) {
264  bool ok = StepSelect::read(line, 2, stringrep);
265  if (ok and keyIndex >= 0)
266  value = (StepCharacterizedDefinition::Code) keyIndex;
267  return (type != NotSet);
268  }
269  void write(std::ostream & os) const {
270  StepSelect::write(os, stringrep);
271  }
272  public:
273  StepCharacterizedDefinition::Code value;
274  private:
275  static const char *stringrep[];
276 };
277 
279 {
280  public:
281  enum Code {
282  product_definition,
283  product_definition_relationship };
284  public:
286  bool read(StepFileLine & line) {
287  bool ok = StepSelect::read(line, 2, stringrep);
288  if (ok and keyIndex >= 0)
289  value = (StepCharacterizedProductDefinition::Code) keyIndex;
290  return (type != NotSet);
291  }
292  void write(std::ostream & os) const {
293  StepSelect::write(os, stringrep);
294  }
295  public:
296  StepCharacterizedProductDefinition::Code value;
297  private:
298  static const char *stringrep[];
299 };
300 
302 {
303  public:
304  enum Code {
305  product_definition_formation,
306  assembly_component_usage };
307  public:
309  bool read(StepFileLine & line) {
310  bool ok = StepSelect::read(line, 2, stringrep);
311  if (ok and keyIndex >= 0)
312  value = (StepClassifiedItem::Code) keyIndex;
313  return (type != NotSet);
314  }
315  void write(std::ostream & os) const {
316  StepSelect::write(os, stringrep);
317  }
318  public:
319  StepClassifiedItem::Code value;
320  private:
321  static const char *stringrep[];
322 };
323 
325 {
326  public:
327  enum Code {
328  product_definition_formation };
329  public:
331  bool read(StepFileLine & line) {
332  bool ok = StepSelect::read(line, 1, stringrep);
333  if (ok and keyIndex >= 0)
334  value = (StepContractedItem::Code) keyIndex;
335  return (type != NotSet);
336  }
337  void write(std::ostream & os) const {
338  StepSelect::write(os, stringrep);
339  }
340  public:
341  StepContractedItem::Code value;
342  private:
343  static const char *stringrep[];
344 };
345 
347 {
348  public:
349  enum Code {
350  pcurve,
351  surface_curve,
352  composite_curve_on_surface };
353  public:
355  bool read(StepFileLine & line) {
356  bool ok = StepSelect::read(line, 3, stringrep);
357  if (ok and keyIndex >= 0)
358  value = (StepCurveOnSurface::Code) keyIndex;
359  return (type != NotSet);
360  }
361  void write(std::ostream & os) const {
362  StepSelect::write(os, stringrep);
363  }
364  public:
365  StepCurveOnSurface::Code value;
366  private:
367  static const char *stringrep[];
368 };
369 
371 {
372  public:
373  enum Code {
374  product_definition,
375  change_request,
376  start_request,
377  change,
378  start_work,
379  approval_person_organization,
380  contract,
381  security_classification,
382  certification };
383  public:
384  StepDateTimeItem() : StepSelect() {}
385  bool read(StepFileLine & line) {
386  bool ok = StepSelect::read(line, 9, stringrep);
387  if (ok and keyIndex >= 0)
388  value = (StepDateTimeItem::Code) keyIndex;
389  return (type != NotSet);
390  }
391  void write(std::ostream & os) const {
392  StepSelect::write(os, stringrep);
393  }
394  public:
395  StepDateTimeItem::Code value;
396  private:
397  static const char *stringrep[];
398 };
399 
401 {
402  public:
403  enum Code {
404  date,
405  local_time,
406  date_and_time };
407  public:
409  bool read(StepFileLine & line) {
410  bool ok = StepSelect::read(line, 3, stringrep);
411  if (ok and keyIndex >= 0)
412  value = (StepDateTimeSelect::Code) keyIndex;
413  return (type != NotSet);
414  }
415  void write(std::ostream & os) const {
416  StepSelect::write(os, stringrep);
417  }
418  public:
419  StepDateTimeSelect::Code value;
420  private:
421  static const char *stringrep[];
422 };
423 
425 {
426  public:
427  enum Code {
428  founded_item,
429  representation_item };
430  public:
432  bool read(StepFileLine & line) {
433  bool ok = StepSelect::read(line, 2, stringrep);
434  if (ok and keyIndex >= 0)
435  value = (StepFoundedItemSelect::Code) keyIndex;
436  return (type != NotSet);
437  }
438  void write(std::ostream & os) const {
439  StepSelect::write(os, stringrep);
440  }
441  public:
442  StepFoundedItemSelect::Code value;
443  private:
444  static const char *stringrep[];
445 };
446 
448 {
449  public:
450  enum Code {
451  point,
452  curve,
453  surface };
454  public:
456  bool read(StepFileLine & line) {
457  bool ok = StepSelect::read(line, 3, stringrep);
458  if (ok and keyIndex >= 0)
459  value = (StepGeometricSetSelect::Code) keyIndex;
460  return (type != NotSet);
461  }
462  void write(std::ostream & os) const {
463  StepSelect::write(os, stringrep);
464  }
465  public:
466  StepGeometricSetSelect::Code value;
467  private:
468  static const char *stringrep[];
469 };
470 
471 class StepKnotType : public StepEnum
472 {
473  public:
474  typedef enum {
475  uniform_knots,
476  unspecified,
477  quasi_uniform_knots,
478  piecewise_bezier_knots } Code;
479  public:
480  bool read(StepFileLine & line) {
481  int iv = 0;
482  bool ok = StepEnum::read(line, 4, stringrep, iv);
483  value = (StepKnotType::Code) iv;
484  return ok;
485  }
486  void write(std::ostream & os) const {
487  int i = (int) value;
488  assert(i < 4);
489  os << stringrep[i];
490  }
491  bool operator== (const StepKnotType & a) const
492  {return value == a.value;}
493  bool operator!= (const StepKnotType & a) const
494  {return value != a.value;}
495  bool operator== (const StepKnotType::Code & a) const
496  {return value == a;}
497  bool operator!= (const StepKnotType::Code & a) const
498  {return value != a;}
499  public:
500  StepKnotType::Code value;
501  private:
502  static const char *stringrep[];
503 };
504 
506 {
507  public:
508  enum Code {
509  length_measure,
510  mass_measure,
511  plane_angle_measure,
512  solid_angle_measure,
513  area_measure,
514  volume_measure,
515  parameter_value,
516  context_dependent_measure,
517  descriptive_measure,
518  positive_length_measure,
519  positive_plane_angle_measure,
520  count_measure };
521  public:
522  StepMeasureValue() : StepSelect() {}
523  bool read(StepFileLine & line) {
524  bool ok = StepSelect::read(line, 12, stringrep);
525  if (ok and keyIndex >= 0)
526  value = (StepMeasureValue::Code) keyIndex;
527  return (type != NotSet);
528  }
529  void write(std::ostream & os) const {
530  StepSelect::write(os, stringrep);
531  }
532  public:
533  StepMeasureValue::Code value;
534  private:
535  static const char *stringrep[];
536 };
537 
539 {
540  public:
541  enum Code {
542  pcurve,
543  surface };
544  public:
546  bool read(StepFileLine & line) {
547  bool ok = StepSelect::read(line, 2, stringrep);
548  if (ok and keyIndex >= 0)
549  value = (StepPcurveOrSurface::Code) keyIndex;
550  return (type != NotSet);
551  }
552  void write(std::ostream & os) const {
553  StepSelect::write(os, stringrep);
554  }
555  public:
556  StepPcurveOrSurface::Code value;
557  private:
558  static const char *stringrep[];
559 };
560 
562 {
563  public:
564  enum Code {
565  change,
566  start_work,
567  change_request,
568  start_request,
569  configuration_item,
570  product,
571  product_definition_formation,
572  product_definition,
573  contract,
574  security_classification };
575  public:
577  bool read(StepFileLine & line) {
578  bool ok = StepSelect::read(line, 10, stringrep);
579  if (ok and keyIndex >= 0)
580  value = (StepPersonOrganizationItem::Code) keyIndex;
581  return (type != NotSet);
582  }
583  void write(std::ostream & os) const {
584  StepSelect::write(os, stringrep);
585  }
586  public:
587  StepPersonOrganizationItem::Code value;
588  private:
589  static const char *stringrep[];
590 };
591 
593 {
594  public:
595  enum Code {
596  person,
597  organization,
598  person_and_organization };
599  public:
601  bool read(StepFileLine & line) {
602  bool ok = StepSelect::read(line, 3, stringrep);
603  if (ok and keyIndex >= 0)
604  value = (StepPersonOrganizationSelect::Code) keyIndex;
605  return (type != NotSet);
606  }
607  void write(std::ostream & os) const {
608  StepSelect::write(os, stringrep);
609  }
610  public:
611  StepPersonOrganizationSelect::Code value;
612  private:
613  static const char *stringrep[];
614 };
615 
617 {
618  public:
619  typedef enum {
620  curve_3d,
621  pcurve_s1,
622  pcurve_s2 } Code;
623  public:
624  bool read(StepFileLine & line) {
625  int iv = 0;
626  bool ok = StepEnum::read(line, 3, stringrep, iv);
627  value = (StepPreferredSurfaceCurveRepresentation::Code) iv;
628  return ok;
629  }
630  void write(std::ostream & os) const {
631  int i = (int) value;
632  assert(i < 3);
633  os << stringrep[i];
634  }
635  bool operator== (const StepPreferredSurfaceCurveRepresentation & a) const
636  {return value == a.value;}
637  bool operator!= (const StepPreferredSurfaceCurveRepresentation & a) const
638  {return value != a.value;}
639  bool operator== (const StepPreferredSurfaceCurveRepresentation::Code & a) const
640  {return value == a;}
641  bool operator!= (const StepPreferredSurfaceCurveRepresentation::Code & a) const
642  {return value != a;}
643  public:
644  StepPreferredSurfaceCurveRepresentation::Code value;
645  private:
646  static const char *stringrep[];
647 };
648 
650 {
651  public:
652  enum Code {
653  reversible_topology_item,
654  list_of_reversible_topology_item,
655  set_of_reversible_topology_item };
656  public:
658  bool read(StepFileLine & line) {
659  bool ok = StepSelect::read(line, 3, stringrep);
660  if (ok and keyIndex >= 0)
661  value = (StepReversibleTopology::Code) keyIndex;
662  return (type != NotSet);
663  }
664  void write(std::ostream & os) const {
665  StepSelect::write(os, stringrep);
666  }
667  public:
668  StepReversibleTopology::Code value;
669  private:
670  static const char *stringrep[];
671 };
672 
674 {
675  public:
676  enum Code {
677  edge,
678  path,
679  face,
680  face_bound,
681  closed_shell,
682  open_shell };
683  public:
685  bool read(StepFileLine & line) {
686  bool ok = StepSelect::read(line, 6, stringrep);
687  if (ok and keyIndex >= 0)
688  value = (StepReversibleTopologyItem::Code) keyIndex;
689  return (type != NotSet);
690  }
691  void write(std::ostream & os) const {
692  StepSelect::write(os, stringrep);
693  }
694  public:
695  StepReversibleTopologyItem::Code value;
696  private:
697  static const char *stringrep[];
698 };
699 
701 {
702  public:
703  enum Code {
704  product_definition_shape,
705  shape_aspect,
706  shape_aspect_relationship };
707  public:
709  bool read(StepFileLine & line) {
710  bool ok = StepSelect::read(line, 3, stringrep);
711  if (ok and keyIndex >= 0)
712  value = (StepShapeDefinition::Code) keyIndex;
713  return (type != NotSet);
714  }
715  void write(std::ostream & os) const {
716  StepSelect::write(os, stringrep);
717  }
718  public:
719  StepShapeDefinition::Code value;
720  private:
721  static const char *stringrep[];
722 };
723 
724 class StepShell : public StepSelect
725 {
726  public:
727  enum Code {
728  vertex_shell,
729  wire_shell,
730  open_shell,
731  closed_shell };
732  public:
733  StepShell() : StepSelect() {}
734  bool read(StepFileLine & line) {
735  bool ok = StepSelect::read(line, 4, stringrep);
736  if (ok and keyIndex >= 0)
737  value = (StepShell::Code) keyIndex;
738  return (type != NotSet);
739  }
740  void write(std::ostream & os) const {
741  StepSelect::write(os, stringrep);
742  }
743  public:
744  StepShell::Code value;
745  private:
746  static const char *stringrep[];
747 };
748 
749 class StepSiPrefix : public StepEnum
750 {
751  public:
752  typedef enum {
753  exa,
754  peta,
755  tera,
756  giga,
757  mega,
758  kilo,
759  hecto,
760  deca,
761  deci,
762  centi,
763  milli,
764  micro,
765  nano,
766  pico,
767  femto,
768  atto } Code;
769  public:
770  bool read(StepFileLine & line) {
771  int iv = 0;
772  bool ok = StepEnum::read(line, 16, stringrep, iv);
773  value = (StepSiPrefix::Code) iv;
774  return ok;
775  }
776  void write(std::ostream & os) const {
777  int i = (int) value;
778  assert(i < 16);
779  os << stringrep[i];
780  }
781  bool operator== (const StepSiPrefix & a) const
782  {return value == a.value;}
783  bool operator!= (const StepSiPrefix & a) const
784  {return value != a.value;}
785  bool operator== (const StepSiPrefix::Code & a) const
786  {return value == a;}
787  bool operator!= (const StepSiPrefix::Code & a) const
788  {return value != a;}
789  public:
790  StepSiPrefix::Code value;
791  private:
792  static const char *stringrep[];
793 };
794 
795 class StepSiUnitName : public StepEnum
796 {
797  public:
798  typedef enum {
799  metre,
800  gram,
801  second,
802  ampere,
803  kelvin,
804  mole,
805  candela,
806  radian,
807  steradian,
808  hertz,
809  newton,
810  pascal,
811  joule,
812  watt,
813  coulomb,
814  volt,
815  farad,
816  ohm,
817  siemens,
818  weber,
819  tesla,
820  henry,
821  degree_celsius,
822  lumen,
823  lux,
824  becquerel,
825  gray,
826  sievert } Code;
827  public:
828  bool read(StepFileLine & line) {
829  int iv = 0;
830  bool ok = StepEnum::read(line, 28, stringrep, iv);
831  value = (StepSiUnitName::Code) iv;
832  return ok;
833  }
834  void write(std::ostream & os) const {
835  int i = (int) value;
836  assert(i < 28);
837  os << stringrep[i];
838  }
839  bool operator== (const StepSiUnitName & a) const
840  {return value == a.value;}
841  bool operator!= (const StepSiUnitName & a) const
842  {return value != a.value;}
843  bool operator== (const StepSiUnitName::Code & a) const
844  {return value == a;}
845  bool operator!= (const StepSiUnitName::Code & a) const
846  {return value != a;}
847  public:
848  StepSiUnitName::Code value;
849  private:
850  static const char *stringrep[];
851 };
852 
853 class StepSource : public StepEnum
854 {
855  public:
856  typedef enum {
857  made,
858  bought,
859  not_known } Code;
860  public:
861  bool read(StepFileLine & line) {
862  int iv = 0;
863  bool ok = StepEnum::read(line, 3, stringrep, iv);
864  value = (StepSource::Code) iv;
865  return ok;
866  }
867  void write(std::ostream & os) const {
868  int i = (int) value;
869  assert(i < 3);
870  os << stringrep[i];
871  }
872  bool operator== (const StepSource & a) const
873  {return value == a.value;}
874  bool operator!= (const StepSource & a) const
875  {return value != a.value;}
876  bool operator== (const StepSource::Code & a) const
877  {return value == a;}
878  bool operator!= (const StepSource::Code & a) const
879  {return value != a;}
880  public:
881  StepSource::Code value;
882  private:
883  static const char *stringrep[];
884 };
885 
887 {
888  public:
889  enum Code {
890  product_definition,
891  shape_aspect };
892  public:
893  StepSpecifiedItem() : StepSelect() {}
894  bool read(StepFileLine & line) {
895  bool ok = StepSelect::read(line, 2, stringrep);
896  if (ok and keyIndex >= 0)
897  value = (StepSpecifiedItem::Code) keyIndex;
898  return (type != NotSet);
899  }
900  void write(std::ostream & os) const {
901  StepSelect::write(os, stringrep);
902  }
903  public:
904  StepSpecifiedItem::Code value;
905  private:
906  static const char *stringrep[];
907 };
908 
910 {
911  public:
912  enum Code {
913  product_definition_formation };
914  public:
916  bool read(StepFileLine & line) {
917  bool ok = StepSelect::read(line, 1, stringrep);
918  if (ok and keyIndex >= 0)
919  value = (StepStartRequestItem::Code) keyIndex;
920  return (type != NotSet);
921  }
922  void write(std::ostream & os) const {
923  StepSelect::write(os, stringrep);
924  }
925  public:
926  StepStartRequestItem::Code value;
927  private:
928  static const char *stringrep[];
929 };
930 
932 {
933  public:
934  enum Code {
935  action_directive,
936  action,
937  action_method };
938  public:
939  StepSupportedItem() : StepSelect() {}
940  bool read(StepFileLine & line) {
941  bool ok = StepSelect::read(line, 3, stringrep);
942  if (ok and keyIndex >= 0)
943  value = (StepSupportedItem::Code) keyIndex;
944  return (type != NotSet);
945  }
946  void write(std::ostream & os) const {
947  StepSelect::write(os, stringrep);
948  }
949  public:
950  StepSupportedItem::Code value;
951  private:
952  static const char *stringrep[];
953 };
954 
956 {
957  public:
958  enum Code {
959  shell_based_surface_model };
960  public:
961  StepSurfaceModel() : StepSelect() {}
962  bool read(StepFileLine & line) {
963  bool ok = StepSelect::read(line, 1, stringrep);
964  if (ok and keyIndex >= 0)
965  value = (StepSurfaceModel::Code) keyIndex;
966  return (type != NotSet);
967  }
968  void write(std::ostream & os) const {
969  StepSelect::write(os, stringrep);
970  }
971  public:
972  StepSurfaceModel::Code value;
973  private:
974  static const char *stringrep[];
975 };
976 
978 {
979  public:
980  enum Code {
981  item_defined_transformation,
982  functionally_defined_transformation };
983  public:
985  bool read(StepFileLine & line) {
986  bool ok = StepSelect::read(line, 2, stringrep);
987  if (ok and keyIndex >= 0)
988  value = (StepTransformation::Code) keyIndex;
989  return (type != NotSet);
990  }
991  void write(std::ostream & os) const {
992  StepSelect::write(os, stringrep);
993  }
994  public:
995  StepTransformation::Code value;
996  private:
997  static const char *stringrep[];
998 };
999 
1001 {
1002  public:
1003  typedef enum {
1004  discontinuous,
1005  continuous,
1006  cont_same_gradient,
1007  cont_same_gradient_same_curvature } Code;
1008  public:
1009  bool read(StepFileLine & line) {
1010  int iv = 0;
1011  bool ok = StepEnum::read(line, 4, stringrep, iv);
1012  value = (StepTransitionCode::Code) iv;
1013  return ok;
1014  }
1015  void write(std::ostream & os) const {
1016  int i = (int) value;
1017  assert(i < 4);
1018  os << stringrep[i];
1019  }
1020  bool operator== (const StepTransitionCode & a) const
1021  {return value == a.value;}
1022  bool operator!= (const StepTransitionCode & a) const
1023  {return value != a.value;}
1024  bool operator== (const StepTransitionCode::Code & a) const
1025  {return value == a;}
1026  bool operator!= (const StepTransitionCode::Code & a) const
1027  {return value != a;}
1028  public:
1029  StepTransitionCode::Code value;
1030  private:
1031  static const char *stringrep[];
1032 };
1033 
1035 {
1036  public:
1037  typedef enum {
1038  cartesian,
1039  parameter,
1040  unspecified } Code;
1041  public:
1042  bool read(StepFileLine & line) {
1043  int iv = 0;
1044  bool ok = StepEnum::read(line, 3, stringrep, iv);
1045  value = (StepTrimmingPreference::Code) iv;
1046  return ok;
1047  }
1048  void write(std::ostream & os) const {
1049  int i = (int) value;
1050  assert(i < 3);
1051  os << stringrep[i];
1052  }
1053  bool operator== (const StepTrimmingPreference & a) const
1054  {return value == a.value;}
1055  bool operator!= (const StepTrimmingPreference & a) const
1056  {return value != a.value;}
1057  bool operator== (const StepTrimmingPreference::Code & a) const
1058  {return value == a;}
1059  bool operator!= (const StepTrimmingPreference::Code & a) const
1060  {return value != a;}
1061  public:
1062  StepTrimmingPreference::Code value;
1063  private:
1064  static const char *stringrep[];
1065 };
1066 
1068 {
1069  public:
1070  enum Code {
1071  cartesian_point,
1072  parameter_value };
1073  public:
1074  StepTrimmingSelect() : StepSelect() {}
1075  bool read(StepFileLine & line) {
1076  bool ok = StepSelect::read(line, 2, stringrep);
1077  if (ok and keyIndex >= 0)
1078  value = (StepTrimmingSelect::Code) keyIndex;
1079  return (type != NotSet);
1080  }
1081  void write(std::ostream & os) const {
1082  StepSelect::write(os, stringrep);
1083  }
1084  public:
1085  StepTrimmingSelect::Code value;
1086  private:
1087  static const char *stringrep[];
1088 };
1089 
1090 class StepUnit : public StepSelect
1091 {
1092  public:
1093  enum Code {
1094  named_unit };
1095  public:
1096  StepUnit() : StepSelect() {}
1097  bool read(StepFileLine & line) {
1098  bool ok = StepSelect::read(line, 1, stringrep);
1099  if (ok and keyIndex >= 0)
1100  value = (StepUnit::Code) keyIndex;
1101  return (type != NotSet);
1102  }
1103  void write(std::ostream & os) const {
1104  StepSelect::write(os, stringrep);
1105  }
1106  public:
1107  StepUnit::Code value;
1108  private:
1109  static const char *stringrep[];
1110 };
1111 
1113 {
1114  public:
1115  enum Code {
1116  vector,
1117  direction };
1118  public:
1120  bool read(StepFileLine & line) {
1121  bool ok = StepSelect::read(line, 2, stringrep);
1122  if (ok and keyIndex >= 0)
1123  value = (StepVectorOrDirection::Code) keyIndex;
1124  return (type != NotSet);
1125  }
1126  void write(std::ostream & os) const {
1127  StepSelect::write(os, stringrep);
1128  }
1129  public:
1130  StepVectorOrDirection::Code value;
1131  private:
1132  static const char *stringrep[];
1133 };
1134 
1136 {
1137  public:
1138  enum Code {
1139  shell_based_wireframe_model,
1140  edge_based_wireframe_model };
1141  public:
1142  StepWireframeModel() : StepSelect() {}
1143  bool read(StepFileLine & line) {
1144  bool ok = StepSelect::read(line, 2, stringrep);
1145  if (ok and keyIndex >= 0)
1146  value = (StepWireframeModel::Code) keyIndex;
1147  return (type != NotSet);
1148  }
1149  void write(std::ostream & os) const {
1150  StepSelect::write(os, stringrep);
1151  }
1152  public:
1153  StepWireframeModel::Code value;
1154  private:
1155  static const char *stringrep[];
1156 };
1157 
1158 class StepWorkItem : public StepSelect
1159 {
1160  public:
1161  enum Code {
1162  product_definition_formation };
1163  public:
1164  StepWorkItem() : StepSelect() {}
1165  bool read(StepFileLine & line) {
1166  bool ok = StepSelect::read(line, 1, stringrep);
1167  if (ok and keyIndex >= 0)
1168  value = (StepWorkItem::Code) keyIndex;
1169  return (type != NotSet);
1170  }
1171  void write(std::ostream & os) const {
1172  StepSelect::write(os, stringrep);
1173  }
1174  public:
1175  StepWorkItem::Code value;
1176  private:
1177  static const char *stringrep[];
1178 };
1179 
1181 {
1182  public:
1183  StepContractAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_contract(0) {}
1184  virtual ~StepContractAssignment() {}
1185  virtual bool read(StepFileLine & line);
1186  virtual void write(std::ostream & os) const;
1187  virtual const char *keyString() const {return "CONTRACT_ASSIGNMENT";}
1188  public:
1189  StepID assigned_contract; // contract
1190 };
1191 
1192 StepEntity *step_create_contract_assignment(StepFileLine & line);
1193 
1195 {
1196  public:
1197  StepRepresentationMap(StepID entityId=0) : StepEntity(entityId) , mapping_origin(0), mapped_representation(0) {}
1198  virtual ~StepRepresentationMap() {}
1199  virtual bool read(StepFileLine & line);
1200  virtual void write(std::ostream & os) const;
1201  virtual const char *keyString() const {return "REPRESENTATION_MAP";}
1202  public:
1203  StepID mapping_origin; // representation_item
1204  StepID mapped_representation; // representation
1205  std::vector<StepID> map_usage; // mapping_source
1206 };
1207 
1208 StepEntity *step_create_representation_map(StepFileLine & line);
1209 
1211 {
1212  public:
1213  StepCertificationAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_certification(0) {}
1214  virtual ~StepCertificationAssignment() {}
1215  virtual bool read(StepFileLine & line);
1216  virtual void write(std::ostream & os) const;
1217  virtual const char *keyString() const {return "CERTIFICATION_ASSIGNMENT";}
1218  public:
1219  StepID assigned_certification; // certification
1220 };
1221 
1222 StepEntity *step_create_certification_assignment(StepFileLine & line);
1223 
1225 {
1226  public:
1227  StepProductCategoryRelationship(StepID entityId=0) : StepEntity(entityId) , category(0), sub_category(0) {}
1228  virtual ~StepProductCategoryRelationship() {}
1229  virtual bool read(StepFileLine & line);
1230  virtual void write(std::ostream & os) const;
1231  virtual const char *keyString() const {return "PRODUCT_CATEGORY_RELATIONSHIP";}
1232  public:
1233  std::string name; // label
1234  std::string description; // text
1235  StepID category; // product_category
1236  StepID sub_category; // product_category
1237 };
1238 
1239 StepEntity *step_create_product_category_relationship(StepFileLine & line);
1240 
1242 {
1243  public:
1244  StepFoundedItem(StepID entityId=0) : StepEntity(entityId) {}
1245  virtual ~StepFoundedItem() {}
1246  virtual bool read(StepFileLine & line);
1247  virtual void write(std::ostream & os) const;
1248  virtual const char *keyString() const {return "FOUNDED_ITEM";}
1249 };
1250 
1251 StepEntity *step_create_founded_item(StepFileLine & line);
1252 
1254 {
1255  public:
1256  StepActionStatus(StepID entityId=0) : StepEntity(entityId) , assigned_action(0) {}
1257  virtual ~StepActionStatus() {}
1258  virtual bool read(StepFileLine & line);
1259  virtual void write(std::ostream & os) const;
1260  virtual const char *keyString() const {return "ACTION_STATUS";}
1261  public:
1262  std::string status; // label
1263  StepID assigned_action; // executed_action
1264 };
1265 
1266 StepEntity *step_create_action_status(StepFileLine & line);
1267 
1268 class StepProduct : public StepEntity
1269 {
1270  public:
1271  StepProduct(StepID entityId=0) : StepEntity(entityId) {}
1272  virtual ~StepProduct() {}
1273  virtual bool read(StepFileLine & line);
1274  virtual void write(std::ostream & os) const;
1275  virtual const char *keyString() const {return "PRODUCT";}
1276  public:
1277  std::string id; // identifier
1278  std::string name; // label
1279  std::string description; // text
1280  std::vector<StepID> frame_of_reference; // product_context
1281 };
1282 
1283 StepEntity *step_create_product(StepFileLine & line);
1284 
1286 {
1287  public:
1288  StepApprovalRelationship(StepID entityId=0) : StepEntity(entityId) , relating_approval(0), related_approval(0) {}
1289  virtual ~StepApprovalRelationship() {}
1290  virtual bool read(StepFileLine & line);
1291  virtual void write(std::ostream & os) const;
1292  virtual const char *keyString() const {return "APPROVAL_RELATIONSHIP";}
1293  public:
1294  std::string name; // label
1295  std::string description; // text
1296  StepID relating_approval; // approval
1297  StepID related_approval; // approval
1298 };
1299 
1300 StepEntity *step_create_approval_relationship(StepFileLine & line);
1301 
1302 class StepContract : public StepEntity
1303 {
1304  public:
1305  StepContract(StepID entityId=0) : StepEntity(entityId) , kind(0) {}
1306  virtual ~StepContract() {}
1307  virtual bool read(StepFileLine & line);
1308  virtual void write(std::ostream & os) const;
1309  virtual const char *keyString() const {return "CONTRACT";}
1310  public:
1311  std::string name; // label
1312  std::string purpose; // text
1313  StepID kind; // contract_type
1314 };
1315 
1316 StepEntity *step_create_contract(StepFileLine & line);
1317 
1319 {
1320  public:
1321  StepRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1322  virtual ~StepRepresentation() {}
1323  virtual bool read(StepFileLine & line);
1324  virtual void write(std::ostream & os) const;
1325  virtual const char *keyString() const {return "REPRESENTATION";}
1326  public:
1327  std::string name; // label
1328  std::vector<StepID> items; // representation_item
1329  StepID context_of_items; // representation_context
1330 };
1331 
1332 StepEntity *step_create_representation(StepFileLine & line);
1333 
1335 {
1336  public:
1337  StepCcDesignCertification(StepID entityId=0) : StepEntity(entityId) , assigned_certification(0) {}
1338  virtual ~StepCcDesignCertification() {}
1339  virtual bool read(StepFileLine & line);
1340  virtual void write(std::ostream & os) const;
1341  virtual const char *keyString() const {return "CC_DESIGN_CERTIFICATION";}
1342  public:
1343  StepID assigned_certification; // certification
1344  std::vector<StepCertifiedItem> items; // certified_item
1345 };
1346 
1347 StepEntity *step_create_cc_design_certification(StepFileLine & line);
1348 
1350 {
1351  public:
1352  StepShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1353  virtual ~StepShapeRepresentation() {}
1354  virtual bool read(StepFileLine & line);
1355  virtual void write(std::ostream & os) const;
1356  virtual const char *keyString() const {return "SHAPE_REPRESENTATION";}
1357  public:
1358  std::string name; // label
1359  std::vector<StepID> items; // representation_item
1360  StepID context_of_items; // representation_context
1361 };
1362 
1363 StepEntity *step_create_shape_representation(StepFileLine & line);
1364 
1366 {
1367  public:
1368  StepOrganization(StepID entityId=0) : StepEntity(entityId) {}
1369  virtual ~StepOrganization() {}
1370  virtual bool read(StepFileLine & line);
1371  virtual void write(std::ostream & os) const;
1372  virtual const char *keyString() const {return "ORGANIZATION";}
1373  public:
1374  std::string id; // identifier
1375  std::string name; // label
1376  std::string description; // text
1377 };
1378 
1379 StepEntity *step_create_organization(StepFileLine & line);
1380 
1382 {
1383  public:
1384  StepProductCategory(StepID entityId=0) : StepEntity(entityId) {}
1385  virtual ~StepProductCategory() {}
1386  virtual bool read(StepFileLine & line);
1387  virtual void write(std::ostream & os) const;
1388  virtual const char *keyString() const {return "PRODUCT_CATEGORY";}
1389  public:
1390  std::string name; // label
1391  std::string description; // text
1392 };
1393 
1394 StepEntity *step_create_product_category(StepFileLine & line);
1395 
1397 {
1398  public:
1399  StepApprovalAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_approval(0) {}
1400  virtual ~StepApprovalAssignment() {}
1401  virtual bool read(StepFileLine & line);
1402  virtual void write(std::ostream & os) const;
1403  virtual const char *keyString() const {return "APPROVAL_ASSIGNMENT";}
1404  public:
1405  StepID assigned_approval; // approval
1406 };
1407 
1408 StepEntity *step_create_approval_assignment(StepFileLine & line);
1409 
1411 {
1412  public:
1413  StepConfigurationItem(StepID entityId=0) : StepEntity(entityId) , item_concept(0) {}
1414  virtual ~StepConfigurationItem() {}
1415  virtual bool read(StepFileLine & line);
1416  virtual void write(std::ostream & os) const;
1417  virtual const char *keyString() const {return "CONFIGURATION_ITEM";}
1418  public:
1419  std::string id; // identifier
1420  std::string name; // label
1421  std::string description; // text
1422  StepID item_concept; // product_concept
1423  std::string purpose; // label
1424 };
1425 
1426 StepEntity *step_create_configuration_item(StepFileLine & line);
1427 
1429 {
1430  public:
1431  StepProductRelatedProductCategory(StepID entityId=0) : StepEntity(entityId) {}
1432  virtual ~StepProductRelatedProductCategory() {}
1433  virtual bool read(StepFileLine & line);
1434  virtual void write(std::ostream & os) const;
1435  virtual const char *keyString() const {return "PRODUCT_RELATED_PRODUCT_CATEGORY";}
1436  public:
1437  std::string name; // label
1438  std::string description; // text
1439  std::vector<StepID> products; // product
1440 };
1441 
1442 StepEntity *step_create_product_related_product_category(StepFileLine & line);
1443 
1445 {
1446  public:
1447  StepDateTimeRole(StepID entityId=0) : StepEntity(entityId) {}
1448  virtual ~StepDateTimeRole() {}
1449  virtual bool read(StepFileLine & line);
1450  virtual void write(std::ostream & os) const;
1451  virtual const char *keyString() const {return "DATE_TIME_ROLE";}
1452  public:
1453  std::string name; // label
1454 };
1455 
1456 StepEntity *step_create_date_time_role(StepFileLine & line);
1457 
1459 {
1460  public:
1461  StepEffectivity(StepID entityId=0) : StepEntity(entityId) {}
1462  virtual ~StepEffectivity() {}
1463  virtual bool read(StepFileLine & line);
1464  virtual void write(std::ostream & os) const;
1465  virtual const char *keyString() const {return "EFFECTIVITY";}
1466  public:
1467  std::string id; // identifier
1468 };
1469 
1470 StepEntity *step_create_effectivity(StepFileLine & line);
1471 
1473 {
1474  public:
1475  StepApplicationContextElement(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
1476  virtual ~StepApplicationContextElement() {}
1477  virtual bool read(StepFileLine & line);
1478  virtual void write(std::ostream & os) const;
1479  virtual const char *keyString() const {return "APPLICATION_CONTEXT_ELEMENT";}
1480  public:
1481  std::string name; // label
1482  StepID frame_of_reference; // application_context
1483 };
1484 
1485 StepEntity *step_create_application_context_element(StepFileLine & line);
1486 
1488 {
1489  public:
1490  StepMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
1491  virtual ~StepMeasureWithUnit() {}
1492  virtual bool read(StepFileLine & line);
1493  virtual void write(std::ostream & os) const;
1494  virtual const char *keyString() const {return "MEASURE_WITH_UNIT";}
1495  public:
1496  StepMeasureValue value_component; // measure_value
1497  StepUnit unit_component; // unit
1498 };
1499 
1500 StepEntity *step_create_measure_with_unit(StepFileLine & line);
1501 
1503 {
1504  public:
1505  StepDimensionalExponents(StepID entityId=0) : StepEntity(entityId) {}
1506  virtual ~StepDimensionalExponents() {}
1507  virtual bool read(StepFileLine & line);
1508  virtual void write(std::ostream & os) const;
1509  virtual const char *keyString() const {return "DIMENSIONAL_EXPONENTS";}
1510  public:
1511  double length_exponent; // REAL
1512  double mass_exponent; // REAL
1513  double time_exponent; // REAL
1514  double electric_current_exponent; // REAL
1515  double thermodynamic_temperature_exponent; // REAL
1516  double amount_of_substance_exponent; // REAL
1517  double luminous_intensity_exponent; // REAL
1518 };
1519 
1520 StepEntity *step_create_dimensional_exponents(StepFileLine & line);
1521 
1523 {
1524  public:
1525  StepSerialNumberedEffectivity(StepID entityId=0) : StepEntity(entityId) {}
1526  virtual ~StepSerialNumberedEffectivity() {}
1527  virtual bool read(StepFileLine & line);
1528  virtual void write(std::ostream & os) const;
1529  virtual const char *keyString() const {return "SERIAL_NUMBERED_EFFECTIVITY";}
1530  public:
1531  std::string id; // identifier
1532  std::string effectivity_start_id; // identifier
1533  std::string effectivity_end_id; // identifier
1534 };
1535 
1536 StepEntity *step_create_serial_numbered_effectivity(StepFileLine & line);
1537 
1539 {
1540  public:
1541  StepVersionedActionRequest(StepID entityId=0) : StepEntity(entityId) {}
1542  virtual ~StepVersionedActionRequest() {}
1543  virtual bool read(StepFileLine & line);
1544  virtual void write(std::ostream & os) const;
1545  virtual const char *keyString() const {return "VERSIONED_ACTION_REQUEST";}
1546  public:
1547  std::string id; // identifier
1548  std::string version; // label
1549  std::string purpose; // text
1550  std::string description; // text
1551 };
1552 
1553 StepEntity *step_create_versioned_action_request(StepFileLine & line);
1554 
1556 {
1557  public:
1558  StepAdvancedBrepShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1560  virtual bool read(StepFileLine & line);
1561  virtual void write(std::ostream & os) const;
1562  virtual const char *keyString() const {return "ADVANCED_BREP_SHAPE_REPRESENTATION";}
1563  public:
1564  std::string name; // label
1565  std::vector<StepID> items; // representation_item
1566  StepID context_of_items; // representation_context
1567 };
1568 
1569 StepEntity *step_create_advanced_brep_shape_representation(StepFileLine & line);
1570 
1572 {
1573  public:
1574  StepProductDefinitionContext(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
1575  virtual ~StepProductDefinitionContext() {}
1576  virtual bool read(StepFileLine & line);
1577  virtual void write(std::ostream & os) const;
1578  virtual const char *keyString() const {return "PRODUCT_DEFINITION_CONTEXT";}
1579  public:
1580  std::string name; // label
1581  StepID frame_of_reference; // application_context
1582  std::string life_cycle_stage; // label
1583 };
1584 
1585 StepEntity *step_create_product_definition_context(StepFileLine & line);
1586 
1588 {
1589  public:
1590  StepProductDefinitionEffectivity(StepID entityId=0) : StepEntity(entityId) , usage(0) {}
1591  virtual ~StepProductDefinitionEffectivity() {}
1592  virtual bool read(StepFileLine & line);
1593  virtual void write(std::ostream & os) const;
1594  virtual const char *keyString() const {return "PRODUCT_DEFINITION_EFFECTIVITY";}
1595  public:
1596  std::string id; // identifier
1597  StepID usage; // product_definition_relationship
1598 };
1599 
1600 StepEntity *step_create_product_definition_effectivity(StepFileLine & line);
1601 
1602 class StepDocument : public StepEntity
1603 {
1604  public:
1605  StepDocument(StepID entityId=0) : StepEntity(entityId) , kind(0) {}
1606  virtual ~StepDocument() {}
1607  virtual bool read(StepFileLine & line);
1608  virtual void write(std::ostream & os) const;
1609  virtual const char *keyString() const {return "DOCUMENT";}
1610  public:
1611  std::string id; // identifier
1612  std::string name; // label
1613  std::string description; // text
1614  StepID kind; // document_type
1615 };
1616 
1617 StepEntity *step_create_document(StepFileLine & line);
1618 
1620 {
1621  public:
1622  StepGeometricallyBoundedSurfaceShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1624  virtual bool read(StepFileLine & line);
1625  virtual void write(std::ostream & os) const;
1626  virtual const char *keyString() const {return "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION";}
1627  public:
1628  std::string name; // label
1629  std::vector<StepID> items; // representation_item
1630  StepID context_of_items; // representation_context
1631 };
1632 
1633 StepEntity *step_create_geometrically_bounded_surface_shape_representation(StepFileLine & line);
1634 
1635 class StepAddress : public StepEntity
1636 {
1637  public:
1638  StepAddress(StepID entityId=0) : StepEntity(entityId) {}
1639  virtual ~StepAddress() {}
1640  virtual bool read(StepFileLine & line);
1641  virtual void write(std::ostream & os) const;
1642  virtual const char *keyString() const {return "ADDRESS";}
1643  public:
1644  std::string internal_location; // label
1645  std::string street_number; // label
1646  std::string street; // label
1647  std::string postal_box; // label
1648  std::string town; // label
1649  std::string region; // label
1650  std::string postal_code; // label
1651  std::string country; // label
1652  std::string facsimile_number; // label
1653  std::string telephone_number; // label
1654  std::string electronic_mail_address; // label
1655  std::string telex_number; // label
1656 };
1657 
1658 StepEntity *step_create_address(StepFileLine & line);
1659 
1661 {
1662  public:
1663  StepMassMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
1664  virtual ~StepMassMeasureWithUnit() {}
1665  virtual bool read(StepFileLine & line);
1666  virtual void write(std::ostream & os) const;
1667  virtual const char *keyString() const {return "MASS_MEASURE_WITH_UNIT";}
1668  public:
1669  StepMeasureValue value_component; // measure_value
1670  StepUnit unit_component; // unit
1671 };
1672 
1673 StepEntity *step_create_mass_measure_with_unit(StepFileLine & line);
1674 
1676 {
1677  public:
1678  StepPropertyDefinition(StepID entityId=0) : StepEntity(entityId) {}
1679  virtual ~StepPropertyDefinition() {}
1680  virtual bool read(StepFileLine & line);
1681  virtual void write(std::ostream & os) const;
1682  virtual const char *keyString() const {return "PROPERTY_DEFINITION";}
1683  public:
1684  std::string name; // label
1685  std::string description; // text
1686  StepCharacterizedDefinition definition; // characterized_definition
1687 };
1688 
1689 StepEntity *step_create_property_definition(StepFileLine & line);
1690 
1692 {
1693  public:
1694  StepOrganizationalProject(StepID entityId=0) : StepEntity(entityId) {}
1695  virtual ~StepOrganizationalProject() {}
1696  virtual bool read(StepFileLine & line);
1697  virtual void write(std::ostream & os) const;
1698  virtual const char *keyString() const {return "ORGANIZATIONAL_PROJECT";}
1699  public:
1700  std::string name; // label
1701  std::string description; // text
1702  std::vector<StepID> responsible_organizations; // organization
1703 };
1704 
1705 StepEntity *step_create_organizational_project(StepFileLine & line);
1706 
1708 {
1709  public:
1710  StepProductConcept(StepID entityId=0) : StepEntity(entityId) , market_context(0) {}
1711  virtual ~StepProductConcept() {}
1712  virtual bool read(StepFileLine & line);
1713  virtual void write(std::ostream & os) const;
1714  virtual const char *keyString() const {return "PRODUCT_CONCEPT";}
1715  public:
1716  std::string id; // identifier
1717  std::string name; // label
1718  std::string description; // text
1719  StepID market_context; // product_concept_context
1720 };
1721 
1722 StepEntity *step_create_product_concept(StepFileLine & line);
1723 
1725 {
1726  public:
1727  StepEdgeBasedWireframeShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1729  virtual bool read(StepFileLine & line);
1730  virtual void write(std::ostream & os) const;
1731  virtual const char *keyString() const {return "EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION";}
1732  public:
1733  std::string name; // label
1734  std::vector<StepID> items; // representation_item
1735  StepID context_of_items; // representation_context
1736 };
1737 
1738 StepEntity *step_create_edge_based_wireframe_shape_representation(StepFileLine & line);
1739 
1741 {
1742  public:
1743  StepContractType(StepID entityId=0) : StepEntity(entityId) {}
1744  virtual ~StepContractType() {}
1745  virtual bool read(StepFileLine & line);
1746  virtual void write(std::ostream & os) const;
1747  virtual const char *keyString() const {return "CONTRACT_TYPE";}
1748  public:
1749  std::string description; // label
1750 };
1751 
1752 StepEntity *step_create_contract_type(StepFileLine & line);
1753 
1755 {
1756  public:
1757  StepProductConceptContext(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
1758  virtual ~StepProductConceptContext() {}
1759  virtual bool read(StepFileLine & line);
1760  virtual void write(std::ostream & os) const;
1761  virtual const char *keyString() const {return "PRODUCT_CONCEPT_CONTEXT";}
1762  public:
1763  std::string name; // label
1764  StepID frame_of_reference; // application_context
1765  std::string market_segment_type; // label
1766 };
1767 
1768 StepEntity *step_create_product_concept_context(StepFileLine & line);
1769 
1770 class StepDate : public StepEntity
1771 {
1772  public:
1773  StepDate(StepID entityId=0) : StepEntity(entityId) {}
1774  virtual ~StepDate() {}
1775  virtual bool read(StepFileLine & line);
1776  virtual void write(std::ostream & os) const;
1777  virtual const char *keyString() const {return "DATE";}
1778  public:
1779  int year_component; // year_number
1780 };
1781 
1782 StepEntity *step_create_date(StepFileLine & line);
1783 
1785 {
1786  public:
1787  StepSecurityClassificationAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_security_classification(0) {}
1789  virtual bool read(StepFileLine & line);
1790  virtual void write(std::ostream & os) const;
1791  virtual const char *keyString() const {return "SECURITY_CLASSIFICATION_ASSIGNMENT";}
1792  public:
1793  StepID assigned_security_classification; // security_classification
1794 };
1795 
1796 StepEntity *step_create_security_classification_assignment(StepFileLine & line);
1797 
1798 class StepPerson : public StepEntity
1799 {
1800  public:
1801  StepPerson(StepID entityId=0) : StepEntity(entityId) {}
1802  virtual ~StepPerson() {}
1803  virtual bool read(StepFileLine & line);
1804  virtual void write(std::ostream & os) const;
1805  virtual const char *keyString() const {return "PERSON";}
1806  public:
1807  std::string id; // identifier
1808  std::string last_name; // label
1809  std::string first_name; // label
1810  std::vector<std::string> middle_names; // label
1811  std::vector<std::string> prefix_titles; // label
1812  std::vector<std::string> suffix_titles; // label
1813 };
1814 
1815 StepEntity *step_create_person(StepFileLine & line);
1816 
1818 {
1819  public:
1820  StepCcDesignContract(StepID entityId=0) : StepEntity(entityId) , assigned_contract(0) {}
1821  virtual ~StepCcDesignContract() {}
1822  virtual bool read(StepFileLine & line);
1823  virtual void write(std::ostream & os) const;
1824  virtual const char *keyString() const {return "CC_DESIGN_CONTRACT";}
1825  public:
1826  StepID assigned_contract; // contract
1827  std::vector<StepContractedItem> items; // contracted_item
1828 };
1829 
1830 StepEntity *step_create_cc_design_contract(StepFileLine & line);
1831 
1833 {
1834  public:
1835  StepApprovalStatus(StepID entityId=0) : StepEntity(entityId) {}
1836  virtual ~StepApprovalStatus() {}
1837  virtual bool read(StepFileLine & line);
1838  virtual void write(std::ostream & os) const;
1839  virtual const char *keyString() const {return "APPROVAL_STATUS";}
1840  public:
1841  std::string name; // label
1842 };
1843 
1844 StepEntity *step_create_approval_status(StepFileLine & line);
1845 
1847 {
1848  public:
1849  StepFacetedBrepShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1851  virtual bool read(StepFileLine & line);
1852  virtual void write(std::ostream & os) const;
1853  virtual const char *keyString() const {return "FACETED_BREP_SHAPE_REPRESENTATION";}
1854  public:
1855  std::string name; // label
1856  std::vector<StepID> items; // representation_item
1857  StepID context_of_items; // representation_context
1858 };
1859 
1860 StepEntity *step_create_faceted_brep_shape_representation(StepFileLine & line);
1861 
1863 {
1864  public:
1865  StepSecurityClassificationLevel(StepID entityId=0) : StepEntity(entityId) {}
1866  virtual ~StepSecurityClassificationLevel() {}
1867  virtual bool read(StepFileLine & line);
1868  virtual void write(std::ostream & os) const;
1869  virtual const char *keyString() const {return "SECURITY_CLASSIFICATION_LEVEL";}
1870  public:
1871  std::string name; // label
1872 };
1873 
1874 StepEntity *step_create_security_classification_level(StepFileLine & line);
1875 
1877 {
1878  public:
1879  StepDefinitionalRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
1880  virtual ~StepDefinitionalRepresentation() {}
1881  virtual bool read(StepFileLine & line);
1882  virtual void write(std::ostream & os) const;
1883  virtual const char *keyString() const {return "DEFINITIONAL_REPRESENTATION";}
1884  public:
1885  std::string name; // label
1886  std::vector<StepID> items; // representation_item
1887  StepID context_of_items; // representation_context
1888 };
1889 
1890 StepEntity *step_create_definitional_representation(StepFileLine & line);
1891 
1893 {
1894  public:
1895  StepSurfacePatch(StepID entityId=0) : StepEntity(entityId) , parent_surface(0) {}
1896  virtual ~StepSurfacePatch() {}
1897  virtual bool read(StepFileLine & line);
1898  virtual void write(std::ostream & os) const;
1899  virtual const char *keyString() const {return "SURFACE_PATCH";}
1900  public:
1901  StepID parent_surface; // bounded_surface
1902  StepTransitionCode u_transition; // transition_code
1903  StepTransitionCode v_transition; // transition_code
1904  bool u_sense; // BOOLEAN
1905  bool v_sense; // BOOLEAN
1906  std::vector<StepID> using_surfaces; // FOR
1907 };
1908 
1909 StepEntity *step_create_surface_patch(StepFileLine & line);
1910 
1912 {
1913  public:
1914  StepCcDesignApproval(StepID entityId=0) : StepEntity(entityId) , assigned_approval(0) {}
1915  virtual ~StepCcDesignApproval() {}
1916  virtual bool read(StepFileLine & line);
1917  virtual void write(std::ostream & os) const;
1918  virtual const char *keyString() const {return "CC_DESIGN_APPROVAL";}
1919  public:
1920  StepID assigned_approval; // approval
1921  std::vector<StepApprovedItem> items; // approved_item
1922 };
1923 
1924 StepEntity *step_create_cc_design_approval(StepFileLine & line);
1925 
1927 {
1928  public:
1929  StepWeekOfYearAndDayDate(StepID entityId=0) : StepEntity(entityId) {}
1930  virtual ~StepWeekOfYearAndDayDate() {}
1931  virtual bool read(StepFileLine & line);
1932  virtual void write(std::ostream & os) const;
1933  virtual const char *keyString() const {return "WEEK_OF_YEAR_AND_DAY_DATE";}
1934  public:
1935  int year_component; // year_number
1936  int week_component; // week_in_year_number
1937  int day_component; // day_in_week_number
1938 };
1939 
1940 StepEntity *step_create_week_of_year_and_day_date(StepFileLine & line);
1941 
1943 {
1944  public:
1945  StepDesignContext(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
1946  virtual ~StepDesignContext() {}
1947  virtual bool read(StepFileLine & line);
1948  virtual void write(std::ostream & os) const;
1949  virtual const char *keyString() const {return "DESIGN_CONTEXT";}
1950  public:
1951  std::string name; // label
1952  StepID frame_of_reference; // application_context
1953  std::string life_cycle_stage; // label
1954 };
1955 
1956 StepEntity *step_create_design_context(StepFileLine & line);
1957 
1959 {
1960  public:
1961  StepLocalTime(StepID entityId=0) : StepEntity(entityId) , zone(0) {}
1962  virtual ~StepLocalTime() {}
1963  virtual bool read(StepFileLine & line);
1964  virtual void write(std::ostream & os) const;
1965  virtual const char *keyString() const {return "LOCAL_TIME";}
1966  public:
1967  int hour_component; // hour_in_day
1968  int minute_component; // minute_in_hour
1969  double second_component; // second_in_minute
1970  StepID zone; // coordinated_universal_time_offset
1971 };
1972 
1973 StepEntity *step_create_local_time(StepFileLine & line);
1974 
1976 {
1977  public:
1978  StepPropertyDefinitionRepresentation(StepID entityId=0) : StepEntity(entityId) , definition(0), used_representation(0) {}
1980  virtual bool read(StepFileLine & line);
1981  virtual void write(std::ostream & os) const;
1982  virtual const char *keyString() const {return "PROPERTY_DEFINITION_REPRESENTATION";}
1983  public:
1984  StepID definition; // property_definition
1985  StepID used_representation; // representation
1986 };
1987 
1988 StepEntity *step_create_property_definition_representation(StepFileLine & line);
1989 
1991 {
1992  public:
1993  StepActionRequestStatus(StepID entityId=0) : StepEntity(entityId) , assigned_request(0) {}
1994  virtual ~StepActionRequestStatus() {}
1995  virtual bool read(StepFileLine & line);
1996  virtual void write(std::ostream & os) const;
1997  virtual const char *keyString() const {return "ACTION_REQUEST_STATUS";}
1998  public:
1999  std::string status; // label
2000  StepID assigned_request; // versioned_action_request
2001 };
2002 
2003 StepEntity *step_create_action_request_status(StepFileLine & line);
2004 
2006 {
2007  public:
2008  StepShapeDefinitionRepresentation(StepID entityId=0) : StepEntity(entityId) , definition(0), used_representation(0) {}
2009  virtual ~StepShapeDefinitionRepresentation() {}
2010  virtual bool read(StepFileLine & line);
2011  virtual void write(std::ostream & os) const;
2012  virtual const char *keyString() const {return "SHAPE_DEFINITION_REPRESENTATION";}
2013  public:
2014  StepID definition; // property_definition
2015  StepID used_representation; // representation
2016 };
2017 
2018 StepEntity *step_create_shape_definition_representation(StepFileLine & line);
2019 
2021 {
2022  public:
2023  StepDocumentReference(StepID entityId=0) : StepEntity(entityId) , assigned_document(0) {}
2024  virtual ~StepDocumentReference() {}
2025  virtual bool read(StepFileLine & line);
2026  virtual void write(std::ostream & os) const;
2027  virtual const char *keyString() const {return "DOCUMENT_REFERENCE";}
2028  public:
2029  StepID assigned_document; // document
2030  std::string source; // label
2031 };
2032 
2033 StepEntity *step_create_document_reference(StepFileLine & line);
2034 
2036 {
2037  public:
2038  StepNamedUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
2039  virtual ~StepNamedUnit() {}
2040  virtual bool read(StepFileLine & line);
2041  virtual void write(std::ostream & os) const;
2042  virtual const char *keyString() const {return "NAMED_UNIT";}
2043  public:
2044  StepID dimensions; // dimensional_exponents
2045 };
2046 
2047 StepEntity *step_create_named_unit(StepFileLine & line);
2048 
2050 {
2051  public:
2052  StepActionRequestAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_action_request(0) {}
2053  virtual ~StepActionRequestAssignment() {}
2054  virtual bool read(StepFileLine & line);
2055  virtual void write(std::ostream & os) const;
2056  virtual const char *keyString() const {return "ACTION_REQUEST_ASSIGNMENT";}
2057  public:
2058  StepID assigned_action_request; // versioned_action_request
2059 };
2060 
2061 StepEntity *step_create_action_request_assignment(StepFileLine & line);
2062 
2064 {
2065  public:
2066  StepDateAndTime(StepID entityId=0) : StepEntity(entityId) , date_component(0), time_component(0) {}
2067  virtual ~StepDateAndTime() {}
2068  virtual bool read(StepFileLine & line);
2069  virtual void write(std::ostream & os) const;
2070  virtual const char *keyString() const {return "DATE_AND_TIME";}
2071  public:
2072  StepID date_component; // date
2073  StepID time_component; // local_time
2074 };
2075 
2076 StepEntity *step_create_date_and_time(StepFileLine & line);
2077 
2079 {
2080  public:
2081  StepConfigurationDesign(StepID entityId=0) : StepEntity(entityId) , configuration(0), design(0) {}
2082  virtual ~StepConfigurationDesign() {}
2083  virtual bool read(StepFileLine & line);
2084  virtual void write(std::ostream & os) const;
2085  virtual const char *keyString() const {return "CONFIGURATION_DESIGN";}
2086  public:
2087  StepID configuration; // configuration_item
2088  StepID design; // product_definition_formation
2089 };
2090 
2091 StepEntity *step_create_configuration_design(StepFileLine & line);
2092 
2094 {
2095  public:
2096  StepContextDependentShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , representation_relation(0), represented_product_relation(0) {}
2098  virtual bool read(StepFileLine & line);
2099  virtual void write(std::ostream & os) const;
2100  virtual const char *keyString() const {return "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION";}
2101  public:
2102  StepID representation_relation; // shape_representation_relationship
2103  StepID represented_product_relation; // product_definition_shape
2104 };
2105 
2106 StepEntity *step_create_context_dependent_shape_representation(StepFileLine & line);
2107 
2109 {
2110  public:
2111  StepRepresentationItem(StepID entityId=0) : StepEntity(entityId) {}
2112  virtual ~StepRepresentationItem() {}
2113  virtual bool read(StepFileLine & line);
2114  virtual void write(std::ostream & os) const;
2115  virtual const char *keyString() const {return "REPRESENTATION_ITEM";}
2116  public:
2117  std::string name; // label
2118 };
2119 
2120 StepEntity *step_create_representation_item(StepFileLine & line);
2121 
2123 {
2124  public:
2125  StepApplicationContext(StepID entityId=0) : StepEntity(entityId) {}
2126  virtual ~StepApplicationContext() {}
2127  virtual bool read(StepFileLine & line);
2128  virtual void write(std::ostream & os) const;
2129  virtual const char *keyString() const {return "APPLICATION_CONTEXT";}
2130  public:
2131  std::string application; // text
2132  std::vector<StepID> context_elements; // FOR
2133 };
2134 
2135 StepEntity *step_create_application_context(StepFileLine & line);
2136 
2138 {
2139  public:
2140  StepOrdinalDate(StepID entityId=0) : StepEntity(entityId) {}
2141  virtual ~StepOrdinalDate() {}
2142  virtual bool read(StepFileLine & line);
2143  virtual void write(std::ostream & os) const;
2144  virtual const char *keyString() const {return "ORDINAL_DATE";}
2145  public:
2146  int year_component; // year_number
2147  int day_component; // day_in_year_number
2148 };
2149 
2150 StepEntity *step_create_ordinal_date(StepFileLine & line);
2151 
2153 {
2154  public:
2155  StepCertificationType(StepID entityId=0) : StepEntity(entityId) {}
2156  virtual ~StepCertificationType() {}
2157  virtual bool read(StepFileLine & line);
2158  virtual void write(std::ostream & os) const;
2159  virtual const char *keyString() const {return "CERTIFICATION_TYPE";}
2160  public:
2161  std::string description; // label
2162 };
2163 
2164 StepEntity *step_create_certification_type(StepFileLine & line);
2165 
2167 {
2168  public:
2169  StepItemDefinedTransformation(StepID entityId=0) : StepEntity(entityId) , transform_item_1(0), transform_item_2(0) {}
2170  virtual ~StepItemDefinedTransformation() {}
2171  virtual bool read(StepFileLine & line);
2172  virtual void write(std::ostream & os) const;
2173  virtual const char *keyString() const {return "ITEM_DEFINED_TRANSFORMATION";}
2174  public:
2175  std::string name; // label
2176  std::string description; // text
2177  StepID transform_item_1; // representation_item
2178  StepID transform_item_2; // representation_item
2179 };
2180 
2181 StepEntity *step_create_item_defined_transformation(StepFileLine & line);
2182 
2184 {
2185  public:
2186  StepConfigurationEffectivity(StepID entityId=0) : StepEntity(entityId) , usage(0), configuration(0) {}
2187  virtual ~StepConfigurationEffectivity() {}
2188  virtual bool read(StepFileLine & line);
2189  virtual void write(std::ostream & os) const;
2190  virtual const char *keyString() const {return "CONFIGURATION_EFFECTIVITY";}
2191  public:
2192  std::string id; // identifier
2193  StepID usage; // product_definition_relationship
2194  StepID configuration; // configuration_design
2195 };
2196 
2197 StepEntity *step_create_configuration_effectivity(StepFileLine & line);
2198 
2200 {
2201  public:
2202  StepDocumentWithClass(StepID entityId=0) : StepEntity(entityId) , kind(0) {}
2203  virtual ~StepDocumentWithClass() {}
2204  virtual bool read(StepFileLine & line);
2205  virtual void write(std::ostream & os) const;
2206  virtual const char *keyString() const {return "DOCUMENT_WITH_CLASS";}
2207  public:
2208  std::string id; // identifier
2209  std::string name; // label
2210  std::string description; // text
2211  StepID kind; // document_type
2212  std::string identifier_class; // identifier
2213 };
2214 
2215 StepEntity *step_create_document_with_class(StepFileLine & line);
2216 
2218 {
2219  public:
2220  StepProductContext(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
2221  virtual ~StepProductContext() {}
2222  virtual bool read(StepFileLine & line);
2223  virtual void write(std::ostream & os) const;
2224  virtual const char *keyString() const {return "PRODUCT_CONTEXT";}
2225  public:
2226  std::string name; // label
2227  StepID frame_of_reference; // application_context
2228  std::string discipline_type; // label
2229 };
2230 
2231 StepEntity *step_create_product_context(StepFileLine & line);
2232 
2234 {
2235  public:
2236  StepDocumentUsageConstraint(StepID entityId=0) : StepEntity(entityId) , source(0) {}
2237  virtual ~StepDocumentUsageConstraint() {}
2238  virtual bool read(StepFileLine & line);
2239  virtual void write(std::ostream & os) const;
2240  virtual const char *keyString() const {return "DOCUMENT_USAGE_CONSTRAINT";}
2241  public:
2242  StepID source; // document
2243  std::string subject_element; // label
2244  std::string subject_element_value; // text
2245 };
2246 
2247 StepEntity *step_create_document_usage_constraint(StepFileLine & line);
2248 
2250 {
2251  public:
2252  StepCcDesignSpecificationReference(StepID entityId=0) : StepEntity(entityId) , assigned_document(0) {}
2254  virtual bool read(StepFileLine & line);
2255  virtual void write(std::ostream & os) const;
2256  virtual const char *keyString() const {return "CC_DESIGN_SPECIFICATION_REFERENCE";}
2257  public:
2258  StepID assigned_document; // document
2259  std::string source; // label
2260  std::vector<StepSpecifiedItem> items; // specified_item
2261 };
2262 
2263 StepEntity *step_create_cc_design_specification_reference(StepFileLine & line);
2264 
2266 {
2267  public:
2268  StepFunctionallyDefinedTransformation(StepID entityId=0) : StepEntity(entityId) {}
2270  virtual bool read(StepFileLine & line);
2271  virtual void write(std::ostream & os) const;
2272  virtual const char *keyString() const {return "FUNCTIONALLY_DEFINED_TRANSFORMATION";}
2273  public:
2274  std::string name; // label
2275  std::string description; // text
2276 };
2277 
2278 StepEntity *step_create_functionally_defined_transformation(StepFileLine & line);
2279 
2281 {
2282  public:
2283  StepPersonalAddress(StepID entityId=0) : StepEntity(entityId) {}
2284  virtual ~StepPersonalAddress() {}
2285  virtual bool read(StepFileLine & line);
2286  virtual void write(std::ostream & os) const;
2287  virtual const char *keyString() const {return "PERSONAL_ADDRESS";}
2288  public:
2289  std::string internal_location; // label
2290  std::string street_number; // label
2291  std::string street; // label
2292  std::string postal_box; // label
2293  std::string town; // label
2294  std::string region; // label
2295  std::string postal_code; // label
2296  std::string country; // label
2297  std::string facsimile_number; // label
2298  std::string telephone_number; // label
2299  std::string electronic_mail_address; // label
2300  std::string telex_number; // label
2301  std::vector<StepID> people; // person
2302  std::string description; // text
2303 };
2304 
2305 StepEntity *step_create_personal_address(StepFileLine & line);
2306 
2308 {
2309  public:
2310  StepVolumeMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
2311  virtual ~StepVolumeMeasureWithUnit() {}
2312  virtual bool read(StepFileLine & line);
2313  virtual void write(std::ostream & os) const;
2314  virtual const char *keyString() const {return "VOLUME_MEASURE_WITH_UNIT";}
2315  public:
2316  StepMeasureValue value_component; // measure_value
2317  StepUnit unit_component; // unit
2318 };
2319 
2320 StepEntity *step_create_volume_measure_with_unit(StepFileLine & line);
2321 
2323 {
2324  public:
2325  StepManifoldSurfaceShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
2327  virtual bool read(StepFileLine & line);
2328  virtual void write(std::ostream & os) const;
2329  virtual const char *keyString() const {return "MANIFOLD_SURFACE_SHAPE_REPRESENTATION";}
2330  public:
2331  std::string name; // label
2332  std::vector<StepID> items; // representation_item
2333  StepID context_of_items; // representation_context
2334 };
2335 
2336 StepEntity *step_create_manifold_surface_shape_representation(StepFileLine & line);
2337 
2339 {
2340  public:
2341  StepShapeAspectRelationship(StepID entityId=0) : StepEntity(entityId) , relating_shape_aspect(0), related_shape_aspect(0) {}
2342  virtual ~StepShapeAspectRelationship() {}
2343  virtual bool read(StepFileLine & line);
2344  virtual void write(std::ostream & os) const;
2345  virtual const char *keyString() const {return "SHAPE_ASPECT_RELATIONSHIP";}
2346  public:
2347  std::string name; // label
2348  std::string description; // text
2349  StepID relating_shape_aspect; // shape_aspect
2350  StepID related_shape_aspect; // shape_aspect
2351 };
2352 
2353 StepEntity *step_create_shape_aspect_relationship(StepFileLine & line);
2354 
2356 {
2357  public:
2358  StepCalendarDate(StepID entityId=0) : StepEntity(entityId) {}
2359  virtual ~StepCalendarDate() {}
2360  virtual bool read(StepFileLine & line);
2361  virtual void write(std::ostream & os) const;
2362  virtual const char *keyString() const {return "CALENDAR_DATE";}
2363  public:
2364  int year_component; // year_number
2365  int day_component; // day_in_month_number
2366  int month_component; // month_in_year_number
2367 };
2368 
2369 StepEntity *step_create_calendar_date(StepFileLine & line);
2370 
2372 {
2373  public:
2374  StepPersonAndOrganizationAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_person_and_organization(0), role(0) {}
2376  virtual bool read(StepFileLine & line);
2377  virtual void write(std::ostream & os) const;
2378  virtual const char *keyString() const {return "PERSON_AND_ORGANIZATION_ASSIGNMENT";}
2379  public:
2380  StepID assigned_person_and_organization; // person_and_organization
2381  StepID role; // person_and_organization_role
2382 };
2383 
2384 StepEntity *step_create_person_and_organization_assignment(StepFileLine & line);
2385 
2387 {
2388  public:
2389  StepActionAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_action(0) {}
2390  virtual ~StepActionAssignment() {}
2391  virtual bool read(StepFileLine & line);
2392  virtual void write(std::ostream & os) const;
2393  virtual const char *keyString() const {return "ACTION_ASSIGNMENT";}
2394  public:
2395  StepID assigned_action; // action
2396 };
2397 
2398 StepEntity *step_create_action_assignment(StepFileLine & line);
2399 
2401 {
2402  public:
2403  StepShapeAspect(StepID entityId=0) : StepEntity(entityId) , of_shape(0) {}
2404  virtual ~StepShapeAspect() {}
2405  virtual bool read(StepFileLine & line);
2406  virtual void write(std::ostream & os) const;
2407  virtual const char *keyString() const {return "SHAPE_ASPECT";}
2408  public:
2409  std::string name; // label
2410  std::string description; // text
2411  StepID of_shape; // product_definition_shape
2412  StepLogical product_definitional; // LOGICAL
2413 };
2414 
2415 StepEntity *step_create_shape_aspect(StepFileLine & line);
2416 
2418 {
2419  public:
2420  StepLengthMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
2421  virtual ~StepLengthMeasureWithUnit() {}
2422  virtual bool read(StepFileLine & line);
2423  virtual void write(std::ostream & os) const;
2424  virtual const char *keyString() const {return "LENGTH_MEASURE_WITH_UNIT";}
2425  public:
2426  StepMeasureValue value_component; // measure_value
2427  StepUnit unit_component; // unit
2428 };
2429 
2430 StepEntity *step_create_length_measure_with_unit(StepFileLine & line);
2431 
2433 {
2434  public:
2435  StepAlternateProductRelationship(StepID entityId=0) : StepEntity(entityId) , alternate(0), base(0) {}
2436  virtual ~StepAlternateProductRelationship() {}
2437  virtual bool read(StepFileLine & line);
2438  virtual void write(std::ostream & os) const;
2439  virtual const char *keyString() const {return "ALTERNATE_PRODUCT_RELATIONSHIP";}
2440  public:
2441  std::string name; // label
2442  std::string definition; // text
2443  StepID alternate; // product
2444  StepID base; // product
2445  std::string basis; // text
2446 };
2447 
2448 StepEntity *step_create_alternate_product_relationship(StepFileLine & line);
2449 
2451 {
2452  public:
2453  StepDocumentRelationship(StepID entityId=0) : StepEntity(entityId) , relating_document(0), related_document(0) {}
2454  virtual ~StepDocumentRelationship() {}
2455  virtual bool read(StepFileLine & line);
2456  virtual void write(std::ostream & os) const;
2457  virtual const char *keyString() const {return "DOCUMENT_RELATIONSHIP";}
2458  public:
2459  std::string name; // label
2460  std::string description; // text
2461  StepID relating_document; // document
2462  StepID related_document; // document
2463 };
2464 
2465 StepEntity *step_create_document_relationship(StepFileLine & line);
2466 
2468 {
2469  public:
2470  StepActionDirective(StepID entityId=0) : StepEntity(entityId) {}
2471  virtual ~StepActionDirective() {}
2472  virtual bool read(StepFileLine & line);
2473  virtual void write(std::ostream & os) const;
2474  virtual const char *keyString() const {return "ACTION_DIRECTIVE";}
2475  public:
2476  std::string name; // label
2477  std::string description; // text
2478  std::string analysis; // text
2479  std::string comment; // text
2480  std::vector<StepID> requests; // versioned_action_request
2481 };
2482 
2483 StepEntity *step_create_action_directive(StepFileLine & line);
2484 
2486 {
2487  public:
2488  StepApplicationProtocolDefinition(StepID entityId=0) : StepEntity(entityId) , application(0) {}
2489  virtual ~StepApplicationProtocolDefinition() {}
2490  virtual bool read(StepFileLine & line);
2491  virtual void write(std::ostream & os) const;
2492  virtual const char *keyString() const {return "APPLICATION_PROTOCOL_DEFINITION";}
2493  public:
2494  std::string status; // label
2495  std::string application_interpreted_model_schema_name; // label
2496  int application_protocol_year; // year_number
2497  StepID application; // application_context
2498 };
2499 
2500 StepEntity *step_create_application_protocol_definition(StepFileLine & line);
2501 
2503 {
2504  public:
2505  StepProductDefinition(StepID entityId=0) : StepEntity(entityId) , formation(0), frame_of_reference(0) {}
2506  virtual ~StepProductDefinition() {}
2507  virtual bool read(StepFileLine & line);
2508  virtual void write(std::ostream & os) const;
2509  virtual const char *keyString() const {return "PRODUCT_DEFINITION";}
2510  public:
2511  std::string id; // identifier
2512  std::string description; // text
2513  StepID formation; // product_definition_formation
2514  StepID frame_of_reference; // product_definition_context
2515 };
2516 
2517 StepEntity *step_create_product_definition(StepFileLine & line);
2518 
2520 {
2521  public:
2522  StepLotEffectivity(StepID entityId=0) : StepEntity(entityId) , effectivity_lot_size(0) {}
2523  virtual ~StepLotEffectivity() {}
2524  virtual bool read(StepFileLine & line);
2525  virtual void write(std::ostream & os) const;
2526  virtual const char *keyString() const {return "LOT_EFFECTIVITY";}
2527  public:
2528  std::string id; // identifier
2529  std::string effectivity_lot_id; // identifier
2530  StepID effectivity_lot_size; // measure_with_unit
2531 };
2532 
2533 StepEntity *step_create_lot_effectivity(StepFileLine & line);
2534 
2536 {
2537  public:
2538  StepShellBasedWireframeShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
2540  virtual bool read(StepFileLine & line);
2541  virtual void write(std::ostream & os) const;
2542  virtual const char *keyString() const {return "SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION";}
2543  public:
2544  std::string name; // label
2545  std::vector<StepID> items; // representation_item
2546  StepID context_of_items; // representation_context
2547 };
2548 
2549 StepEntity *step_create_shell_based_wireframe_shape_representation(StepFileLine & line);
2550 
2552 {
2553  public:
2554  StepCoordinatedUniversalTimeOffset(StepID entityId=0) : StepEntity(entityId) {}
2556  virtual bool read(StepFileLine & line);
2557  virtual void write(std::ostream & os) const;
2558  virtual const char *keyString() const {return "COORDINATED_UNIVERSAL_TIME_OFFSET";}
2559  public:
2560  int hour_offset; // hour_in_day
2561  int minute_offset; // minute_in_hour
2562  StepAheadOrBehind sense; // ahead_or_behind
2563 };
2564 
2565 StepEntity *step_create_coordinated_universal_time_offset(StepFileLine & line);
2566 
2568 {
2569  public:
2570  StepApprovalPersonOrganization(StepID entityId=0) : StepEntity(entityId) , authorized_approval(0), role(0) {}
2571  virtual ~StepApprovalPersonOrganization() {}
2572  virtual bool read(StepFileLine & line);
2573  virtual void write(std::ostream & os) const;
2574  virtual const char *keyString() const {return "APPROVAL_PERSON_ORGANIZATION";}
2575  public:
2576  StepPersonOrganizationSelect person_organization; // person_organization_select
2577  StepID authorized_approval; // approval
2578  StepID role; // approval_role
2579 };
2580 
2581 StepEntity *step_create_approval_person_organization(StepFileLine & line);
2582 
2584 {
2585  public:
2586  StepSolidAngleMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
2587  virtual ~StepSolidAngleMeasureWithUnit() {}
2588  virtual bool read(StepFileLine & line);
2589  virtual void write(std::ostream & os) const;
2590  virtual const char *keyString() const {return "SOLID_ANGLE_MEASURE_WITH_UNIT";}
2591  public:
2592  StepMeasureValue value_component; // measure_value
2593  StepUnit unit_component; // unit
2594 };
2595 
2596 StepEntity *step_create_solid_angle_measure_with_unit(StepFileLine & line);
2597 
2599 {
2600  public:
2601  StepSecurityClassification(StepID entityId=0) : StepEntity(entityId) , security_level(0) {}
2602  virtual ~StepSecurityClassification() {}
2603  virtual bool read(StepFileLine & line);
2604  virtual void write(std::ostream & os) const;
2605  virtual const char *keyString() const {return "SECURITY_CLASSIFICATION";}
2606  public:
2607  std::string name; // label
2608  std::string purpose; // text
2609  StepID security_level; // security_classification_level
2610 };
2611 
2612 StepEntity *step_create_security_classification(StepFileLine & line);
2613 
2615 {
2616  public:
2617  StepPlaneAngleMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
2618  virtual ~StepPlaneAngleMeasureWithUnit() {}
2619  virtual bool read(StepFileLine & line);
2620  virtual void write(std::ostream & os) const;
2621  virtual const char *keyString() const {return "PLANE_ANGLE_MEASURE_WITH_UNIT";}
2622  public:
2623  StepMeasureValue value_component; // measure_value
2624  StepUnit unit_component; // unit
2625 };
2626 
2627 StepEntity *step_create_plane_angle_measure_with_unit(StepFileLine & line);
2628 
2630 {
2631  public:
2632  StepProductDefinitionRelationship(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
2633  virtual ~StepProductDefinitionRelationship() {}
2634  virtual bool read(StepFileLine & line);
2635  virtual void write(std::ostream & os) const;
2636  virtual const char *keyString() const {return "PRODUCT_DEFINITION_RELATIONSHIP";}
2637  public:
2638  std::string id; // identifier
2639  std::string name; // label
2640  std::string description; // text
2641  StepID relating_product_definition; // product_definition
2642  StepID related_product_definition; // product_definition
2643 };
2644 
2645 StepEntity *step_create_product_definition_relationship(StepFileLine & line);
2646 
2648 {
2649  public:
2650  StepRepresentationContext(StepID entityId=0) : StepEntity(entityId) {}
2651  virtual ~StepRepresentationContext() {}
2652  virtual bool read(StepFileLine & line);
2653  virtual void write(std::ostream & os) const;
2654  virtual const char *keyString() const {return "REPRESENTATION_CONTEXT";}
2655  public:
2656  std::string context_identifier; // identifier
2657  std::string context_type; // text
2658  std::vector<StepID> representations_in_context; // FOR
2659 };
2660 
2661 StepEntity *step_create_representation_context(StepFileLine & line);
2662 
2664 {
2665  public:
2666  StepDatedEffectivity(StepID entityId=0) : StepEntity(entityId) , effectivity_start_date(0), effectivity_end_date(0) {}
2667  virtual ~StepDatedEffectivity() {}
2668  virtual bool read(StepFileLine & line);
2669  virtual void write(std::ostream & os) const;
2670  virtual const char *keyString() const {return "DATED_EFFECTIVITY";}
2671  public:
2672  std::string id; // identifier
2673  StepID effectivity_start_date; // date_and_time
2674  StepID effectivity_end_date; // date_and_time
2675 };
2676 
2677 StepEntity *step_create_dated_effectivity(StepFileLine & line);
2678 
2680 {
2681  public:
2682  StepCompositeCurveSegment(StepID entityId=0) : StepEntity(entityId) , parent_curve(0) {}
2683  virtual ~StepCompositeCurveSegment() {}
2684  virtual bool read(StepFileLine & line);
2685  virtual void write(std::ostream & os) const;
2686  virtual const char *keyString() const {return "COMPOSITE_CURVE_SEGMENT";}
2687  public:
2688  StepTransitionCode transition; // transition_code
2689  bool same_sense; // BOOLEAN
2690  StepID parent_curve; // curve
2691  std::vector<StepID> using_curves; // segments
2692 };
2693 
2694 StepEntity *step_create_composite_curve_segment(StepFileLine & line);
2695 
2697 {
2698  public:
2699  StepSolidAngleUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
2700  virtual ~StepSolidAngleUnit() {}
2701  virtual bool read(StepFileLine & line);
2702  virtual void write(std::ostream & os) const;
2703  virtual const char *keyString() const {return "SOLID_ANGLE_UNIT";}
2704  public:
2705  StepID dimensions; // dimensional_exponents
2706 };
2707 
2708 StepEntity *step_create_solid_angle_unit(StepFileLine & line);
2709 
2711 {
2712  public:
2713  StepActionMethod(StepID entityId=0) : StepEntity(entityId) {}
2714  virtual ~StepActionMethod() {}
2715  virtual bool read(StepFileLine & line);
2716  virtual void write(std::ostream & os) const;
2717  virtual const char *keyString() const {return "ACTION_METHOD";}
2718  public:
2719  std::string name; // label
2720  std::string description; // text
2721  std::string consequence; // text
2722  std::string purpose; // text
2723 };
2724 
2725 StepEntity *step_create_action_method(StepFileLine & line);
2726 
2728 {
2729  public:
2730  StepOrganizationRelationship(StepID entityId=0) : StepEntity(entityId) , relating_organization(0), related_organization(0) {}
2731  virtual ~StepOrganizationRelationship() {}
2732  virtual bool read(StepFileLine & line);
2733  virtual void write(std::ostream & os) const;
2734  virtual const char *keyString() const {return "ORGANIZATION_RELATIONSHIP";}
2735  public:
2736  std::string name; // label
2737  std::string description; // text
2738  StepID relating_organization; // organization
2739  StepID related_organization; // organization
2740 };
2741 
2742 StepEntity *step_create_organization_relationship(StepFileLine & line);
2743 
2745 {
2746  public:
2747  StepStartRequest(StepID entityId=0) : StepEntity(entityId) , assigned_action_request(0) {}
2748  virtual ~StepStartRequest() {}
2749  virtual bool read(StepFileLine & line);
2750  virtual void write(std::ostream & os) const;
2751  virtual const char *keyString() const {return "START_REQUEST";}
2752  public:
2753  StepID assigned_action_request; // versioned_action_request
2754  std::vector<StepStartRequestItem> items; // start_request_item
2755 };
2756 
2757 StepEntity *step_create_start_request(StepFileLine & line);
2758 
2759 class StepAction : public StepEntity
2760 {
2761  public:
2762  StepAction(StepID entityId=0) : StepEntity(entityId) , chosen_method(0) {}
2763  virtual ~StepAction() {}
2764  virtual bool read(StepFileLine & line);
2765  virtual void write(std::ostream & os) const;
2766  virtual const char *keyString() const {return "ACTION";}
2767  public:
2768  std::string name; // label
2769  std::string description; // text
2770  StepID chosen_method; // action_method
2771 };
2772 
2773 StepEntity *step_create_action(StepFileLine & line);
2774 
2775 class StepChange : public StepEntity
2776 {
2777  public:
2778  StepChange(StepID entityId=0) : StepEntity(entityId) , assigned_action(0) {}
2779  virtual ~StepChange() {}
2780  virtual bool read(StepFileLine & line);
2781  virtual void write(std::ostream & os) const;
2782  virtual const char *keyString() const {return "CHANGE";}
2783  public:
2784  StepID assigned_action; // action
2785  std::vector<StepWorkItem> items; // work_item
2786 };
2787 
2788 StepEntity *step_create_change(StepFileLine & line);
2789 
2791 {
2792  public:
2793  StepChangeRequest(StepID entityId=0) : StepEntity(entityId) , assigned_action_request(0) {}
2794  virtual ~StepChangeRequest() {}
2795  virtual bool read(StepFileLine & line);
2796  virtual void write(std::ostream & os) const;
2797  virtual const char *keyString() const {return "CHANGE_REQUEST";}
2798  public:
2799  StepID assigned_action_request; // versioned_action_request
2800  std::vector<StepChangeRequestItem> items; // change_request_item
2801 };
2802 
2803 StepEntity *step_create_change_request(StepFileLine & line);
2804 
2806 {
2807  public:
2808  StepAreaMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
2809  virtual ~StepAreaMeasureWithUnit() {}
2810  virtual bool read(StepFileLine & line);
2811  virtual void write(std::ostream & os) const;
2812  virtual const char *keyString() const {return "AREA_MEASURE_WITH_UNIT";}
2813  public:
2814  StepMeasureValue value_component; // measure_value
2815  StepUnit unit_component; // unit
2816 };
2817 
2818 StepEntity *step_create_area_measure_with_unit(StepFileLine & line);
2819 
2821 {
2822  public:
2823  StepApprovalDateTime(StepID entityId=0) : StepEntity(entityId) , dated_approval(0) {}
2824  virtual ~StepApprovalDateTime() {}
2825  virtual bool read(StepFileLine & line);
2826  virtual void write(std::ostream & os) const;
2827  virtual const char *keyString() const {return "APPROVAL_DATE_TIME";}
2828  public:
2829  StepDateTimeSelect date_time; // date_time_select
2830  StepID dated_approval; // approval
2831 };
2832 
2833 StepEntity *step_create_approval_date_time(StepFileLine & line);
2834 
2836 {
2837  public:
2838  StepApprovalRole(StepID entityId=0) : StepEntity(entityId) {}
2839  virtual ~StepApprovalRole() {}
2840  virtual bool read(StepFileLine & line);
2841  virtual void write(std::ostream & os) const;
2842  virtual const char *keyString() const {return "APPROVAL_ROLE";}
2843  public:
2844  std::string role; // label
2845 };
2846 
2847 StepEntity *step_create_approval_role(StepFileLine & line);
2848 
2850 {
2851  public:
2852  StepPersonAndOrganizationRole(StepID entityId=0) : StepEntity(entityId) {}
2853  virtual ~StepPersonAndOrganizationRole() {}
2854  virtual bool read(StepFileLine & line);
2855  virtual void write(std::ostream & os) const;
2856  virtual const char *keyString() const {return "PERSON_AND_ORGANIZATION_ROLE";}
2857  public:
2858  std::string name; // label
2859 };
2860 
2861 StepEntity *step_create_person_and_organization_role(StepFileLine & line);
2862 
2864 {
2865  public:
2866  StepVolumeUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
2867  virtual ~StepVolumeUnit() {}
2868  virtual bool read(StepFileLine & line);
2869  virtual void write(std::ostream & os) const;
2870  virtual const char *keyString() const {return "VOLUME_UNIT";}
2871  public:
2872  StepID dimensions; // dimensional_exponents
2873 };
2874 
2875 StepEntity *step_create_volume_unit(StepFileLine & line);
2876 
2878 {
2879  public:
2880  StepProductDefinitionFormation(StepID entityId=0) : StepEntity(entityId) , of_product(0) {}
2881  virtual ~StepProductDefinitionFormation() {}
2882  virtual bool read(StepFileLine & line);
2883  virtual void write(std::ostream & os) const;
2884  virtual const char *keyString() const {return "PRODUCT_DEFINITION_FORMATION";}
2885  public:
2886  std::string id; // identifier
2887  std::string description; // text
2888  StepID of_product; // product
2889 };
2890 
2891 StepEntity *step_create_product_definition_formation(StepFileLine & line);
2892 
2893 class StepApproval : public StepEntity
2894 {
2895  public:
2896  StepApproval(StepID entityId=0) : StepEntity(entityId) , status(0) {}
2897  virtual ~StepApproval() {}
2898  virtual bool read(StepFileLine & line);
2899  virtual void write(std::ostream & os) const;
2900  virtual const char *keyString() const {return "APPROVAL";}
2901  public:
2902  StepID status; // approval_status
2903  std::string level; // label
2904 };
2905 
2906 StepEntity *step_create_approval(StepFileLine & line);
2907 
2909 {
2910  public:
2911  StepTopologicalRepresentationItem(StepID entityId=0) : StepEntity(entityId) {}
2912  virtual ~StepTopologicalRepresentationItem() {}
2913  virtual bool read(StepFileLine & line);
2914  virtual void write(std::ostream & os) const;
2915  virtual const char *keyString() const {return "TOPOLOGICAL_REPRESENTATION_ITEM";}
2916  public:
2917  std::string name; // label
2918 };
2919 
2920 StepEntity *step_create_topological_representation_item(StepFileLine & line);
2921 
2923 {
2924  public:
2925  StepProductDefinitionUsage(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
2926  virtual ~StepProductDefinitionUsage() {}
2927  virtual bool read(StepFileLine & line);
2928  virtual void write(std::ostream & os) const;
2929  virtual const char *keyString() const {return "PRODUCT_DEFINITION_USAGE";}
2930  public:
2931  std::string id; // identifier
2932  std::string name; // label
2933  std::string description; // text
2934  StepID relating_product_definition; // product_definition
2935  StepID related_product_definition; // product_definition
2936 };
2937 
2938 StepEntity *step_create_product_definition_usage(StepFileLine & line);
2939 
2941 {
2942  public:
2943  StepActionRequestSolution(StepID entityId=0) : StepEntity(entityId) , method(0), request(0) {}
2944  virtual ~StepActionRequestSolution() {}
2945  virtual bool read(StepFileLine & line);
2946  virtual void write(std::ostream & os) const;
2947  virtual const char *keyString() const {return "ACTION_REQUEST_SOLUTION";}
2948  public:
2949  StepID method; // action_method
2950  StepID request; // versioned_action_request
2951 };
2952 
2953 StepEntity *step_create_action_request_solution(StepFileLine & line);
2954 
2956 {
2957  public:
2958  StepRepresentationRelationship(StepID entityId=0) : StepEntity(entityId) , rep_1(0), rep_2(0) {}
2959  virtual ~StepRepresentationRelationship() {}
2960  virtual bool read(StepFileLine & line);
2961  virtual void write(std::ostream & os) const;
2962  virtual const char *keyString() const {return "REPRESENTATION_RELATIONSHIP";}
2963  public:
2964  std::string name; // label
2965  std::string description; // text
2966  StepID rep_1; // representation
2967  StepID rep_2; // representation
2968 };
2969 
2970 StepEntity *step_create_representation_relationship(StepFileLine & line);
2971 
2973 {
2974  public:
2975  StepDocumentType(StepID entityId=0) : StepEntity(entityId) {}
2976  virtual ~StepDocumentType() {}
2977  virtual bool read(StepFileLine & line);
2978  virtual void write(std::ostream & os) const;
2979  virtual const char *keyString() const {return "DOCUMENT_TYPE";}
2980  public:
2981  std::string product_data_type; // label
2982 };
2983 
2984 StepEntity *step_create_document_type(StepFileLine & line);
2985 
2987 {
2988  public:
2989  StepDateAndTimeAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_date_and_time(0), role(0) {}
2990  virtual ~StepDateAndTimeAssignment() {}
2991  virtual bool read(StepFileLine & line);
2992  virtual void write(std::ostream & os) const;
2993  virtual const char *keyString() const {return "DATE_AND_TIME_ASSIGNMENT";}
2994  public:
2995  StepID assigned_date_and_time; // date_and_time
2996  StepID role; // date_time_role
2997 };
2998 
2999 StepEntity *step_create_date_and_time_assignment(StepFileLine & line);
3000 
3002 {
3003  public:
3004  StepPersonAndOrganization(StepID entityId=0) : StepEntity(entityId) , the_person(0), the_organization(0) {}
3005  virtual ~StepPersonAndOrganization() {}
3006  virtual bool read(StepFileLine & line);
3007  virtual void write(std::ostream & os) const;
3008  virtual const char *keyString() const {return "PERSON_AND_ORGANIZATION";}
3009  public:
3010  StepID the_person; // person
3011  StepID the_organization; // organization
3012 };
3013 
3014 StepEntity *step_create_person_and_organization(StepFileLine & line);
3015 
3017 {
3018  public:
3019  StepCertification(StepID entityId=0) : StepEntity(entityId) , kind(0) {}
3020  virtual ~StepCertification() {}
3021  virtual bool read(StepFileLine & line);
3022  virtual void write(std::ostream & os) const;
3023  virtual const char *keyString() const {return "CERTIFICATION";}
3024  public:
3025  std::string name; // label
3026  std::string purpose; // text
3027  StepID kind; // certification_type
3028 };
3029 
3030 StepEntity *step_create_certification(StepFileLine & line);
3031 
3032 class StepVertex : public StepEntity
3033 {
3034  public:
3035  StepVertex(StepID entityId=0) : StepEntity(entityId) {}
3036  virtual ~StepVertex() {}
3037  virtual bool read(StepFileLine & line);
3038  virtual void write(std::ostream & os) const;
3039  virtual const char *keyString() const {return "VERTEX";}
3040  public:
3041  std::string name; // label
3042 };
3043 
3044 StepEntity *step_create_vertex(StepFileLine & line);
3045 
3047 {
3048  public:
3049  StepProductDefinitionShape(StepID entityId=0) : StepEntity(entityId) {}
3050  virtual ~StepProductDefinitionShape() {}
3051  virtual bool read(StepFileLine & line);
3052  virtual void write(std::ostream & os) const;
3053  virtual const char *keyString() const {return "PRODUCT_DEFINITION_SHAPE";}
3054  public:
3055  std::string name; // label
3056  std::string description; // text
3057  StepCharacterizedDefinition definition; // characterized_definition
3058 };
3059 
3060 StepEntity *step_create_product_definition_shape(StepFileLine & line);
3061 
3063 {
3064  public:
3065  StepAssemblyComponentUsageSubstitute(StepID entityId=0) : StepEntity(entityId) , base(0), substitute(0) {}
3067  virtual bool read(StepFileLine & line);
3068  virtual void write(std::ostream & os) const;
3069  virtual const char *keyString() const {return "ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE";}
3070  public:
3071  std::string name; // label
3072  std::string definition; // text
3073  StepID base; // assembly_component_usage
3074  StepID substitute; // assembly_component_usage
3075 };
3076 
3077 StepEntity *step_create_assembly_component_usage_substitute(StepFileLine & line);
3078 
3080 {
3081  public:
3082  StepConversionBasedUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0), conversion_factor(0) {}
3083  virtual ~StepConversionBasedUnit() {}
3084  virtual bool read(StepFileLine & line);
3085  virtual void write(std::ostream & os) const;
3086  virtual const char *keyString() const {return "CONVERSION_BASED_UNIT";}
3087  public:
3088  StepID dimensions; // dimensional_exponents
3089  std::string name; // label
3090  StepID conversion_factor; // measure_with_unit
3091 };
3092 
3093 StepEntity *step_create_conversion_based_unit(StepFileLine & line);
3094 
3096 {
3097  public:
3098  StepExecutedAction(StepID entityId=0) : StepEntity(entityId) , chosen_method(0) {}
3099  virtual ~StepExecutedAction() {}
3100  virtual bool read(StepFileLine & line);
3101  virtual void write(std::ostream & os) const;
3102  virtual const char *keyString() const {return "EXECUTED_ACTION";}
3103  public:
3104  std::string name; // label
3105  std::string description; // text
3106  StepID chosen_method; // action_method
3107 };
3108 
3109 StepEntity *step_create_executed_action(StepFileLine & line);
3110 
3112 {
3113  public:
3114  StepCcDesignSecurityClassification(StepID entityId=0) : StepEntity(entityId) , assigned_security_classification(0) {}
3116  virtual bool read(StepFileLine & line);
3117  virtual void write(std::ostream & os) const;
3118  virtual const char *keyString() const {return "CC_DESIGN_SECURITY_CLASSIFICATION";}
3119  public:
3120  StepID assigned_security_classification; // security_classification
3121  std::vector<StepClassifiedItem> items; // classified_item
3122 };
3123 
3124 StepEntity *step_create_cc_design_security_classification(StepFileLine & line);
3125 
3126 class StepEdge : public StepEntity
3127 {
3128  public:
3129  StepEdge(StepID entityId=0) : StepEntity(entityId) , edge_start(0), edge_end(0) {}
3130  virtual ~StepEdge() {}
3131  virtual bool read(StepFileLine & line);
3132  virtual void write(std::ostream & os) const;
3133  virtual const char *keyString() const {return "EDGE";}
3134  public:
3135  std::string name; // label
3136  StepID edge_start; // vertex
3137  StepID edge_end; // vertex
3138 };
3139 
3140 StepEntity *step_create_edge(StepFileLine & line);
3141 
3143 {
3144  public:
3145  StepSuppliedPartRelationship(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
3146  virtual ~StepSuppliedPartRelationship() {}
3147  virtual bool read(StepFileLine & line);
3148  virtual void write(std::ostream & os) const;
3149  virtual const char *keyString() const {return "SUPPLIED_PART_RELATIONSHIP";}
3150  public:
3151  std::string id; // identifier
3152  std::string name; // label
3153  std::string description; // text
3154  StepID relating_product_definition; // product_definition
3155  StepID related_product_definition; // product_definition
3156 };
3157 
3158 StepEntity *step_create_supplied_part_relationship(StepFileLine & line);
3159 
3161 {
3162  public:
3163  StepStartWork(StepID entityId=0) : StepEntity(entityId) , assigned_action(0) {}
3164  virtual ~StepStartWork() {}
3165  virtual bool read(StepFileLine & line);
3166  virtual void write(std::ostream & os) const;
3167  virtual const char *keyString() const {return "START_WORK";}
3168  public:
3169  StepID assigned_action; // action
3170  std::vector<StepWorkItem> items; // work_item
3171 };
3172 
3173 StepEntity *step_create_start_work(StepFileLine & line);
3174 
3176 {
3177  public:
3178  StepOrganizationalAddress(StepID entityId=0) : StepEntity(entityId) {}
3179  virtual ~StepOrganizationalAddress() {}
3180  virtual bool read(StepFileLine & line);
3181  virtual void write(std::ostream & os) const;
3182  virtual const char *keyString() const {return "ORGANIZATIONAL_ADDRESS";}
3183  public:
3184  std::string internal_location; // label
3185  std::string street_number; // label
3186  std::string street; // label
3187  std::string postal_box; // label
3188  std::string town; // label
3189  std::string region; // label
3190  std::string postal_code; // label
3191  std::string country; // label
3192  std::string facsimile_number; // label
3193  std::string telephone_number; // label
3194  std::string electronic_mail_address; // label
3195  std::string telex_number; // label
3196  std::vector<StepID> organizations; // organization
3197  std::string description; // text
3198 };
3199 
3200 StepEntity *step_create_organizational_address(StepFileLine & line);
3201 
3203 {
3204  public:
3205  StepMappedItem(StepID entityId=0) : StepEntity(entityId) , mapping_source(0), mapping_target(0) {}
3206  virtual ~StepMappedItem() {}
3207  virtual bool read(StepFileLine & line);
3208  virtual void write(std::ostream & os) const;
3209  virtual const char *keyString() const {return "MAPPED_ITEM";}
3210  public:
3211  std::string name; // label
3212  StepID mapping_source; // representation_map
3213  StepID mapping_target; // representation_item
3214 };
3215 
3216 StepEntity *step_create_mapped_item(StepFileLine & line);
3217 
3219 {
3220  public:
3221  StepGlobalUnitAssignedContext(StepID entityId=0) : StepEntity(entityId) {}
3222  virtual ~StepGlobalUnitAssignedContext() {}
3223  virtual bool read(StepFileLine & line);
3224  virtual void write(std::ostream & os) const;
3225  virtual const char *keyString() const {return "GLOBAL_UNIT_ASSIGNED_CONTEXT";}
3226  public:
3227  std::string context_identifier; // identifier
3228  std::string context_type; // text
3229  std::vector<StepID> representations_in_context; // FOR
3230  std::vector<StepUnit> units; // unit
3231 };
3232 
3233 StepEntity *step_create_global_unit_assigned_context(StepFileLine & line);
3234 
3236 {
3237  public:
3238  StepReparametrisedCompositeCurveSegment(StepID entityId=0) : StepEntity(entityId) , parent_curve(0) {}
3240  virtual bool read(StepFileLine & line);
3241  virtual void write(std::ostream & os) const;
3242  virtual const char *keyString() const {return "REPARAMETRISED_COMPOSITE_CURVE_SEGMENT";}
3243  public:
3244  StepTransitionCode transition; // transition_code
3245  bool same_sense; // BOOLEAN
3246  StepID parent_curve; // curve
3247  std::vector<StepID> using_curves; // segments
3248  double param_length; // parameter_value
3249 };
3250 
3251 StepEntity *step_create_reparametrised_composite_curve_segment(StepFileLine & line);
3252 
3253 class StepLoop : public StepEntity
3254 {
3255  public:
3256  StepLoop(StepID entityId=0) : StepEntity(entityId) {}
3257  virtual ~StepLoop() {}
3258  virtual bool read(StepFileLine & line);
3259  virtual void write(std::ostream & os) const;
3260  virtual const char *keyString() const {return "LOOP";}
3261  public:
3262  std::string name; // label
3263 };
3264 
3265 StepEntity *step_create_loop(StepFileLine & line);
3266 
3268 {
3269  public:
3270  StepProductDefinitionFormationWithSpecifiedSource(StepID entityId=0) : StepEntity(entityId) , of_product(0) {}
3272  virtual bool read(StepFileLine & line);
3273  virtual void write(std::ostream & os) const;
3274  virtual const char *keyString() const {return "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE";}
3275  public:
3276  std::string id; // identifier
3277  std::string description; // text
3278  StepID of_product; // product
3279  StepSource make_or_buy; // source
3280 };
3281 
3282 StepEntity *step_create_product_definition_formation_with_specified_source(StepFileLine & line);
3283 
3285 {
3286  public:
3287  StepProductDefinitionWithAssociatedDocuments(StepID entityId=0) : StepEntity(entityId) , formation(0), frame_of_reference(0) {}
3289  virtual bool read(StepFileLine & line);
3290  virtual void write(std::ostream & os) const;
3291  virtual const char *keyString() const {return "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS";}
3292  public:
3293  std::string id; // identifier
3294  std::string description; // text
3295  StepID formation; // product_definition_formation
3296  StepID frame_of_reference; // product_definition_context
3297  std::vector<StepID> documentation_ids; // document
3298 };
3299 
3300 StepEntity *step_create_product_definition_with_associated_documents(StepFileLine & line);
3301 
3303 {
3304  public:
3305  StepPlaneAngleUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3306  virtual ~StepPlaneAngleUnit() {}
3307  virtual bool read(StepFileLine & line);
3308  virtual void write(std::ostream & os) const;
3309  virtual const char *keyString() const {return "PLANE_ANGLE_UNIT";}
3310  public:
3311  StepID dimensions; // dimensional_exponents
3312 };
3313 
3314 StepEntity *step_create_plane_angle_unit(StepFileLine & line);
3315 
3317 {
3318  public:
3319  StepLengthUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3320  virtual ~StepLengthUnit() {}
3321  virtual bool read(StepFileLine & line);
3322  virtual void write(std::ostream & os) const;
3323  virtual const char *keyString() const {return "LENGTH_UNIT";}
3324  public:
3325  StepID dimensions; // dimensional_exponents
3326 };
3327 
3328 StepEntity *step_create_length_unit(StepFileLine & line);
3329 
3330 class StepAreaUnit : public StepEntity
3331 {
3332  public:
3333  StepAreaUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3334  virtual ~StepAreaUnit() {}
3335  virtual bool read(StepFileLine & line);
3336  virtual void write(std::ostream & os) const;
3337  virtual const char *keyString() const {return "AREA_UNIT";}
3338  public:
3339  StepID dimensions; // dimensional_exponents
3340 };
3341 
3342 StepEntity *step_create_area_unit(StepFileLine & line);
3343 
3345 {
3346  public:
3347  StepGeometricRepresentationContext(StepID entityId=0) : StepEntity(entityId) {}
3349  virtual bool read(StepFileLine & line);
3350  virtual void write(std::ostream & os) const;
3351  virtual const char *keyString() const {return "GEOMETRIC_REPRESENTATION_CONTEXT";}
3352  public:
3353  std::string context_identifier; // identifier
3354  std::string context_type; // text
3355  std::vector<StepID> representations_in_context; // FOR
3356  int coordinate_space_dimension; // dimension_count
3357 };
3358 
3359 StepEntity *step_create_geometric_representation_context(StepFileLine & line);
3360 
3362 {
3363  public:
3364  StepWireShell(StepID entityId=0) : StepEntity(entityId) {}
3365  virtual ~StepWireShell() {}
3366  virtual bool read(StepFileLine & line);
3367  virtual void write(std::ostream & os) const;
3368  virtual const char *keyString() const {return "WIRE_SHELL";}
3369  public:
3370  std::string name; // label
3371  std::vector<StepID> wire_shell_extent; // loop
3372 };
3373 
3374 StepEntity *step_create_wire_shell(StepFileLine & line);
3375 
3377 {
3378  public:
3379  StepAssemblyComponentUsage(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
3380  virtual ~StepAssemblyComponentUsage() {}
3381  virtual bool read(StepFileLine & line);
3382  virtual void write(std::ostream & os) const;
3383  virtual const char *keyString() const {return "ASSEMBLY_COMPONENT_USAGE";}
3384  public:
3385  std::string id; // identifier
3386  std::string name; // label
3387  std::string description; // text
3388  StepID relating_product_definition; // product_definition
3389  StepID related_product_definition; // product_definition
3390  std::string reference_designator; // identifier
3391 };
3392 
3393 StepEntity *step_create_assembly_component_usage(StepFileLine & line);
3394 
3395 class StepFace : public StepEntity
3396 {
3397  public:
3398  StepFace(StepID entityId=0) : StepEntity(entityId) {}
3399  virtual ~StepFace() {}
3400  virtual bool read(StepFileLine & line);
3401  virtual void write(std::ostream & os) const;
3402  virtual const char *keyString() const {return "FACE";}
3403  public:
3404  std::string name; // label
3405  std::vector<StepID> bounds; // face_bound
3406 };
3407 
3408 StepEntity *step_create_face(StepFileLine & line);
3409 
3410 class StepSiUnit : public StepEntity
3411 {
3412  public:
3413  StepSiUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3414  virtual ~StepSiUnit() {}
3415  virtual bool read(StepFileLine & line);
3416  virtual void write(std::ostream & os) const;
3417  virtual const char *keyString() const {return "SI_UNIT";}
3418  public:
3419  StepID dimensions; // dimensional_exponents
3420  StepSiPrefix prefix; // si_prefix
3421  StepSiUnitName name; // si_unit_name
3422 };
3423 
3424 StepEntity *step_create_si_unit(StepFileLine & line);
3425 
3427 {
3428  public:
3429  StepUncertaintyMeasureWithUnit(StepID entityId=0) : StepEntity(entityId) {}
3430  virtual ~StepUncertaintyMeasureWithUnit() {}
3431  virtual bool read(StepFileLine & line);
3432  virtual void write(std::ostream & os) const;
3433  virtual const char *keyString() const {return "UNCERTAINTY_MEASURE_WITH_UNIT";}
3434  public:
3435  StepMeasureValue value_component; // measure_value
3436  StepUnit unit_component; // unit
3437  std::string name; // label
3438  std::string description; // text
3439 };
3440 
3441 StepEntity *step_create_uncertainty_measure_with_unit(StepFileLine & line);
3442 
3443 class StepPath : public StepEntity
3444 {
3445  public:
3446  StepPath(StepID entityId=0) : StepEntity(entityId) {}
3447  virtual ~StepPath() {}
3448  virtual bool read(StepFileLine & line);
3449  virtual void write(std::ostream & os) const;
3450  virtual const char *keyString() const {return "PATH";}
3451  public:
3452  std::string name; // label
3453  std::vector<StepID> edge_list; // oriented_edge
3454 };
3455 
3456 StepEntity *step_create_path(StepFileLine & line);
3457 
3459 {
3460  public:
3461  StepConnectedFaceSet(StepID entityId=0) : StepEntity(entityId) {}
3462  virtual ~StepConnectedFaceSet() {}
3463  virtual bool read(StepFileLine & line);
3464  virtual void write(std::ostream & os) const;
3465  virtual const char *keyString() const {return "CONNECTED_FACE_SET";}
3466  public:
3467  std::string name; // label
3468  std::vector<StepID> cfs_faces; // face
3469 };
3470 
3471 StepEntity *step_create_connected_face_set(StepFileLine & line);
3472 
3474 {
3475  public:
3476  StepOrientedFace(StepID entityId=0) : StepEntity(entityId) , face_element(0) {}
3477  virtual ~StepOrientedFace() {}
3478  virtual bool read(StepFileLine & line);
3479  virtual void write(std::ostream & os) const;
3480  virtual const char *keyString() const {return "ORIENTED_FACE";}
3481  public:
3482  std::string name; // label
3483  std::vector<StepID> bounds; // face_bound
3484  StepID face_element; // face
3485  bool orientation; // BOOLEAN
3486 };
3487 
3488 StepEntity *step_create_oriented_face(StepFileLine & line);
3489 
3491 {
3492  public:
3493  StepGeometricallyBoundedWireframeShapeRepresentation(StepID entityId=0) : StepEntity(entityId) , context_of_items(0) {}
3495  virtual bool read(StepFileLine & line);
3496  virtual void write(std::ostream & os) const;
3497  virtual const char *keyString() const {return "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION";}
3498  public:
3499  std::string name; // label
3500  std::vector<StepID> items; // representation_item
3501  StepID context_of_items; // representation_context
3502 };
3503 
3504 StepEntity *step_create_geometrically_bounded_wireframe_shape_representation(StepFileLine & line);
3505 
3506 class StepMassUnit : public StepEntity
3507 {
3508  public:
3509  StepMassUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3510  virtual ~StepMassUnit() {}
3511  virtual bool read(StepFileLine & line);
3512  virtual void write(std::ostream & os) const;
3513  virtual const char *keyString() const {return "MASS_UNIT";}
3514  public:
3515  StepID dimensions; // dimensional_exponents
3516 };
3517 
3518 StepEntity *step_create_mass_unit(StepFileLine & line);
3519 
3521 {
3522  public:
3523  StepParametricRepresentationContext(StepID entityId=0) : StepEntity(entityId) {}
3525  virtual bool read(StepFileLine & line);
3526  virtual void write(std::ostream & os) const;
3527  virtual const char *keyString() const {return "PARAMETRIC_REPRESENTATION_CONTEXT";}
3528  public:
3529  std::string context_identifier; // identifier
3530  std::string context_type; // text
3531  std::vector<StepID> representations_in_context; // FOR
3532 };
3533 
3534 StepEntity *step_create_parametric_representation_context(StepFileLine & line);
3535 
3537 {
3538  public:
3539  StepSpecifiedHigherUsageOccurrence(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0), upper_usage(0), next_usage(0) {}
3541  virtual bool read(StepFileLine & line);
3542  virtual void write(std::ostream & os) const;
3543  virtual const char *keyString() const {return "SPECIFIED_HIGHER_USAGE_OCCURRENCE";}
3544  public:
3545  std::string id; // identifier
3546  std::string name; // label
3547  std::string description; // text
3548  StepID relating_product_definition; // product_definition
3549  StepID related_product_definition; // product_definition
3550  std::string reference_designator; // identifier
3551  StepID upper_usage; // assembly_component_usage
3552  StepID next_usage; // next_assembly_usage_occurrence
3553 };
3554 
3555 StepEntity *step_create_specified_higher_usage_occurrence(StepFileLine & line);
3556 
3558 {
3559  public:
3560  StepGeometricRepresentationItem(StepID entityId=0) : StepEntity(entityId) {}
3561  virtual ~StepGeometricRepresentationItem() {}
3562  virtual bool read(StepFileLine & line);
3563  virtual void write(std::ostream & os) const;
3564  virtual const char *keyString() const {return "GEOMETRIC_REPRESENTATION_ITEM";}
3565  public:
3566  std::string name; // label
3567 };
3568 
3569 StepEntity *step_create_geometric_representation_item(StepFileLine & line);
3570 
3572 {
3573  public:
3574  StepCcDesignDateAndTimeAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_date_and_time(0), role(0) {}
3575  virtual ~StepCcDesignDateAndTimeAssignment() {}
3576  virtual bool read(StepFileLine & line);
3577  virtual void write(std::ostream & os) const;
3578  virtual const char *keyString() const {return "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT";}
3579  public:
3580  StepID assigned_date_and_time; // date_and_time
3581  StepID role; // date_time_role
3582  std::vector<StepDateTimeItem> items; // date_time_item
3583 };
3584 
3585 StepEntity *step_create_cc_design_date_and_time_assignment(StepFileLine & line);
3586 
3588 {
3589  public:
3590  StepGeometricSet(StepID entityId=0) : StepEntity(entityId) {}
3591  virtual ~StepGeometricSet() {}
3592  virtual bool read(StepFileLine & line);
3593  virtual void write(std::ostream & os) const;
3594  virtual const char *keyString() const {return "GEOMETRIC_SET";}
3595  public:
3596  std::string name; // label
3597  std::vector<StepGeometricSetSelect> elements; // geometric_set_select
3598 };
3599 
3600 StepEntity *step_create_geometric_set(StepFileLine & line);
3601 
3603 {
3604  public:
3605  StepCcDesignPersonAndOrganizationAssignment(StepID entityId=0) : StepEntity(entityId) , assigned_person_and_organization(0), role(0) {}
3607  virtual bool read(StepFileLine & line);
3608  virtual void write(std::ostream & os) const;
3609  virtual const char *keyString() const {return "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT";}
3610  public:
3611  StepID assigned_person_and_organization; // person_and_organization
3612  StepID role; // person_and_organization_role
3613  std::vector<StepPersonOrganizationItem> items; // person_organization_item
3614 };
3615 
3616 StepEntity *step_create_cc_design_person_and_organization_assignment(StepFileLine & line);
3617 
3619 {
3620  public:
3621  StepConnectedEdgeSet(StepID entityId=0) : StepEntity(entityId) {}
3622  virtual ~StepConnectedEdgeSet() {}
3623  virtual bool read(StepFileLine & line);
3624  virtual void write(std::ostream & os) const;
3625  virtual const char *keyString() const {return "CONNECTED_EDGE_SET";}
3626  public:
3627  std::string name; // label
3628  std::vector<StepID> ces_edges; // edge
3629 };
3630 
3631 StepEntity *step_create_connected_edge_set(StepFileLine & line);
3632 
3634 {
3635  public:
3636  StepContextDependentUnit(StepID entityId=0) : StepEntity(entityId) , dimensions(0) {}
3637  virtual ~StepContextDependentUnit() {}
3638  virtual bool read(StepFileLine & line);
3639  virtual void write(std::ostream & os) const;
3640  virtual const char *keyString() const {return "CONTEXT_DEPENDENT_UNIT";}
3641  public:
3642  StepID dimensions; // dimensional_exponents
3643  std::string name; // label
3644 };
3645 
3646 StepEntity *step_create_context_dependent_unit(StepFileLine & line);
3647 
3649 {
3650  public:
3651  StepGeometricCurveSet(StepID entityId=0) : StepEntity(entityId) {}
3652  virtual ~StepGeometricCurveSet() {}
3653  virtual bool read(StepFileLine & line);
3654  virtual void write(std::ostream & os) const;
3655  virtual const char *keyString() const {return "GEOMETRIC_CURVE_SET";}
3656  public:
3657  std::string name; // label
3658  std::vector<StepGeometricSetSelect> elements; // geometric_set_select
3659 };
3660 
3661 StepEntity *step_create_geometric_curve_set(StepFileLine & line);
3662 
3664 {
3665  public:
3666  StepOrientedEdge(StepID entityId=0) : StepEntity(entityId) , edge_start(0), edge_end(0), edge_element(0) {}
3667  virtual ~StepOrientedEdge() {}
3668  virtual bool read(StepFileLine & line);
3669  virtual void write(std::ostream & os) const;
3670  virtual const char *keyString() const {return "ORIENTED_EDGE";}
3671  public:
3672  std::string name; // label
3673  StepID edge_start; // vertex
3674  StepID edge_end; // vertex
3675  StepID edge_element; // edge
3676  bool orientation; // BOOLEAN
3677 };
3678 
3679 StepEntity *step_create_oriented_edge(StepFileLine & line);
3680 
3682 {
3683  public:
3684  StepClosedShell(StepID entityId=0) : StepEntity(entityId) {}
3685  virtual ~StepClosedShell() {}
3686  virtual bool read(StepFileLine & line);
3687  virtual void write(std::ostream & os) const;
3688  virtual const char *keyString() const {return "CLOSED_SHELL";}
3689  public:
3690  std::string name; // label
3691  std::vector<StepID> cfs_faces; // face
3692 };
3693 
3694 StepEntity *step_create_closed_shell(StepFileLine & line);
3695 
3697 {
3698  public:
3699  StepShapeRepresentationRelationship(StepID entityId=0) : StepEntity(entityId) , rep_1(0), rep_2(0) {}
3701  virtual bool read(StepFileLine & line);
3702  virtual void write(std::ostream & os) const;
3703  virtual const char *keyString() const {return "SHAPE_REPRESENTATION_RELATIONSHIP";}
3704  public:
3705  std::string name; // label
3706  std::string description; // text
3707  StepID rep_1; // representation
3708  StepID rep_2; // representation
3709 };
3710 
3711 StepEntity *step_create_shape_representation_relationship(StepFileLine & line);
3712 
3714 {
3715  public:
3716  StepGlobalUncertaintyAssignedContext(StepID entityId=0) : StepEntity(entityId) {}
3718  virtual bool read(StepFileLine & line);
3719  virtual void write(std::ostream & os) const;
3720  virtual const char *keyString() const {return "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT";}
3721  public:
3722  std::string context_identifier; // identifier
3723  std::string context_type; // text
3724  std::vector<StepID> representations_in_context; // FOR
3725  std::vector<StepID> uncertainty; // uncertainty_measure_with_unit
3726 };
3727 
3728 StepEntity *step_create_global_uncertainty_assigned_context(StepFileLine & line);
3729 
3731 {
3732  public:
3733  StepRepresentationRelationshipWithTransformation(StepID entityId=0) : StepEntity(entityId) , rep_1(0), rep_2(0) {}
3735  virtual bool read(StepFileLine & line);
3736  virtual void write(std::ostream & os) const;
3737  virtual const char *keyString() const {return "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION";}
3738  public:
3739  std::string name; // label
3740  std::string description; // text
3741  StepID rep_1; // representation
3742  StepID rep_2; // representation
3743  StepTransformation transformation_operator; // transformation
3744 };
3745 
3746 StepEntity *step_create_representation_relationship_with_transformation(StepFileLine & line);
3747 
3749 {
3750  public:
3751  StepMechanicalContext(StepID entityId=0) : StepEntity(entityId) , frame_of_reference(0) {}
3752  virtual ~StepMechanicalContext() {}
3753  virtual bool read(StepFileLine & line);
3754  virtual void write(std::ostream & os) const;
3755  virtual const char *keyString() const {return "MECHANICAL_CONTEXT";}
3756  public:
3757  std::string name; // label
3758  StepID frame_of_reference; // application_context
3759  std::string discipline_type; // label
3760 };
3761 
3762 StepEntity *step_create_mechanical_context(StepFileLine & line);
3763 
3765 {
3766  public:
3767  StepOrientedClosedShell(StepID entityId=0) : StepEntity(entityId) , closed_shell_element(0) {}
3768  virtual ~StepOrientedClosedShell() {}
3769  virtual bool read(StepFileLine & line);
3770  virtual void write(std::ostream & os) const;
3771  virtual const char *keyString() const {return "ORIENTED_CLOSED_SHELL";}
3772  public:
3773  std::string name; // label
3774  std::vector<StepID> cfs_faces; // face
3775  StepID closed_shell_element; // closed_shell
3776  bool orientation; // BOOLEAN
3777 };
3778 
3779 StepEntity *step_create_oriented_closed_shell(StepFileLine & line);
3780 
3782 {
3783  public:
3784  StepDirection(StepID entityId=0) : StepEntity(entityId) {}
3785  virtual ~StepDirection() {}
3786  virtual bool read(StepFileLine & line);
3787  virtual void write(std::ostream & os) const;
3788  virtual const char *keyString() const {return "DIRECTION";}
3789  public:
3790  std::string name; // label
3791  double direction_ratios[3]; // REAL
3792 };
3793 
3794 StepEntity *step_create_direction(StepFileLine & line);
3795 
3797 {
3798  public:
3799  StepVertexShell(StepID entityId=0) : StepEntity(entityId) , vertex_shell_extent(0) {}
3800  virtual ~StepVertexShell() {}
3801  virtual bool read(StepFileLine & line);
3802  virtual void write(std::ostream & os) const;
3803  virtual const char *keyString() const {return "VERTEX_SHELL";}
3804  public:
3805  std::string name; // label
3806  StepID vertex_shell_extent; // vertex_loop
3807 };
3808 
3809 StepEntity *step_create_vertex_shell(StepFileLine & line);
3810 
3812 {
3813  public:
3814  StepNextAssemblyUsageOccurrence(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
3815  virtual ~StepNextAssemblyUsageOccurrence() {}
3816  virtual bool read(StepFileLine & line);
3817  virtual void write(std::ostream & os) const;
3818  virtual const char *keyString() const {return "NEXT_ASSEMBLY_USAGE_OCCURRENCE";}
3819  public:
3820  std::string id; // identifier
3821  std::string name; // label
3822  std::string description; // text
3823  StepID relating_product_definition; // product_definition
3824  StepID related_product_definition; // product_definition
3825  std::string reference_designator; // identifier
3826 };
3827 
3828 StepEntity *step_create_next_assembly_usage_occurrence(StepFileLine & line);
3829 
3831 {
3832  public:
3833  StepOrientedPath(StepID entityId=0) : StepEntity(entityId) , path_element(0) {}
3834  virtual ~StepOrientedPath() {}
3835  virtual bool read(StepFileLine & line);
3836  virtual void write(std::ostream & os) const;
3837  virtual const char *keyString() const {return "ORIENTED_PATH";}
3838  public:
3839  std::string name; // label
3840  std::vector<StepID> edge_list; // oriented_edge
3841  StepID path_element; // path
3842  bool orientation; // BOOLEAN
3843 };
3844 
3845 StepEntity *step_create_oriented_path(StepFileLine & line);
3846 
3848 {
3849  public:
3850  StepFaceBound(StepID entityId=0) : StepEntity(entityId) , bound(0) {}
3851  virtual ~StepFaceBound() {}
3852  virtual bool read(StepFileLine & line);
3853  virtual void write(std::ostream & os) const;
3854  virtual const char *keyString() const {return "FACE_BOUND";}
3855  public:
3856  std::string name; // label
3857  StepID bound; // loop
3858  bool orientation; // BOOLEAN
3859 };
3860 
3861 StepEntity *step_create_face_bound(StepFileLine & line);
3862 
3863 class StepVector : public StepEntity
3864 {
3865  public:
3866  StepVector(StepID entityId=0) : StepEntity(entityId) , orientation(0) {}
3867  virtual ~StepVector() {}
3868  virtual bool read(StepFileLine & line);
3869  virtual void write(std::ostream & os) const;
3870  virtual const char *keyString() const {return "VECTOR";}
3871  public:
3872  std::string name; // label
3873  StepID orientation; // direction
3874  double magnitude; // length_measure
3875 };
3876 
3877 StepEntity *step_create_vector(StepFileLine & line);
3878 
3880 {
3881  public:
3882  StepDirectedAction(StepID entityId=0) : StepEntity(entityId) , chosen_method(0), directive(0) {}
3883  virtual ~StepDirectedAction() {}
3884  virtual bool read(StepFileLine & line);
3885  virtual void write(std::ostream & os) const;
3886  virtual const char *keyString() const {return "DIRECTED_ACTION";}
3887  public:
3888  std::string name; // label
3889  std::string description; // text
3890  StepID chosen_method; // action_method
3891  StepID directive; // action_directive
3892 };
3893 
3894 StepEntity *step_create_directed_action(StepFileLine & line);
3895 
3896 class StepSurface : public StepEntity
3897 {
3898  public:
3899  StepSurface(StepID entityId=0) : StepEntity(entityId) {}
3900  virtual ~StepSurface() {}
3901  virtual bool read(StepFileLine & line);
3902  virtual void write(std::ostream & os) const;
3903  virtual const char *keyString() const {return "SURFACE";}
3904  public:
3905  std::string name; // label
3906 };
3907 
3908 StepEntity *step_create_surface(StepFileLine & line);
3909 
3911 {
3912  public:
3913  StepShellBasedSurfaceModel(StepID entityId=0) : StepEntity(entityId) {}
3914  virtual ~StepShellBasedSurfaceModel() {}
3915  virtual bool read(StepFileLine & line);
3916  virtual void write(std::ostream & os) const;
3917  virtual const char *keyString() const {return "SHELL_BASED_SURFACE_MODEL";}
3918  public:
3919  std::string name; // label
3920  std::vector<StepShell> sbsm_boundary; // shell
3921 };
3922 
3923 StepEntity *step_create_shell_based_surface_model(StepFileLine & line);
3924 
3926 {
3927  public:
3928  StepDesignMakeFromRelationship(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
3929  virtual ~StepDesignMakeFromRelationship() {}
3930  virtual bool read(StepFileLine & line);
3931  virtual void write(std::ostream & os) const;
3932  virtual const char *keyString() const {return "DESIGN_MAKE_FROM_RELATIONSHIP";}
3933  public:
3934  std::string id; // identifier
3935  std::string name; // label
3936  std::string description; // text
3937  StepID relating_product_definition; // product_definition
3938  StepID related_product_definition; // product_definition
3939 };
3940 
3941 StepEntity *step_create_design_make_from_relationship(StepFileLine & line);
3942 
3943 class StepPolyLoop : public StepEntity
3944 {
3945  public:
3946  StepPolyLoop(StepID entityId=0) : StepEntity(entityId) {}
3947  virtual ~StepPolyLoop() {}
3948  virtual bool read(StepFileLine & line);
3949  virtual void write(std::ostream & os) const;
3950  virtual const char *keyString() const {return "POLY_LOOP";}
3951  public:
3952  std::string name; // label
3953  std::vector<StepID> polygon; // cartesian_point
3954 };
3955 
3956 StepEntity *step_create_poly_loop(StepFileLine & line);
3957 
3958 class StepCurve : public StepEntity
3959 {
3960  public:
3961  StepCurve(StepID entityId=0) : StepEntity(entityId) {}
3962  virtual ~StepCurve() {}
3963  virtual bool read(StepFileLine & line);
3964  virtual void write(std::ostream & os) const;
3965  virtual const char *keyString() const {return "CURVE";}
3966  public:
3967  std::string name; // label
3968 };
3969 
3970 StepEntity *step_create_curve(StepFileLine & line);
3971 
3973 {
3974  public:
3975  StepPromissoryUsageOccurrence(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0) {}
3976  virtual ~StepPromissoryUsageOccurrence() {}
3977  virtual bool read(StepFileLine & line);
3978  virtual void write(std::ostream & os) const;
3979  virtual const char *keyString() const {return "PROMISSORY_USAGE_OCCURRENCE";}
3980  public:
3981  std::string id; // identifier
3982  std::string name; // label
3983  std::string description; // text
3984  StepID relating_product_definition; // product_definition
3985  StepID related_product_definition; // product_definition
3986  std::string reference_designator; // identifier
3987 };
3988 
3989 StepEntity *step_create_promissory_usage_occurrence(StepFileLine & line);
3990 
3991 class StepPoint : public StepEntity
3992 {
3993  public:
3994  StepPoint(StepID entityId=0) : StepEntity(entityId) {}
3995  virtual ~StepPoint() {}
3996  virtual bool read(StepFileLine & line);
3997  virtual void write(std::ostream & os) const;
3998  virtual const char *keyString() const {return "POINT";}
3999  public:
4000  std::string name; // label
4001 };
4002 
4003 StepEntity *step_create_point(StepFileLine & line);
4004 
4006 {
4007  public:
4008  StepQuantifiedAssemblyComponentUsage(StepID entityId=0) : StepEntity(entityId) , relating_product_definition(0), related_product_definition(0), quantity(0) {}
4010  virtual bool read(StepFileLine & line);
4011  virtual void write(std::ostream & os) const;
4012  virtual const char *keyString() const {return "QUANTIFIED_ASSEMBLY_COMPONENT_USAGE";}
4013  public:
4014  std::string id; // identifier
4015  std::string name; // label
4016  std::string description; // text
4017  StepID relating_product_definition; // product_definition
4018  StepID related_product_definition; // product_definition
4019  std::string reference_designator; // identifier
4020  StepID quantity; // measure_with_unit
4021 };
4022 
4023 StepEntity *step_create_quantified_assembly_component_usage(StepFileLine & line);
4024 
4026 {
4027  public:
4028  StepFaceOuterBound(StepID entityId=0) : StepEntity(entityId) , bound(0) {}
4029  virtual ~StepFaceOuterBound() {}
4030  virtual bool read(StepFileLine & line);
4031  virtual void write(std::ostream & os) const;
4032  virtual const char *keyString() const {return "FACE_OUTER_BOUND";}
4033  public:
4034  std::string name; // label
4035  StepID bound; // loop
4036  bool orientation; // BOOLEAN
4037 };
4038 
4039 StepEntity *step_create_face_outer_bound(StepFileLine & line);
4040 
4042 {
4043  public:
4044  StepOpenShell(StepID entityId=0) : StepEntity(entityId) {}
4045  virtual ~StepOpenShell() {}
4046  virtual bool read(StepFileLine & line);
4047  virtual void write(std::ostream & os) const;
4048  virtual const char *keyString() const {return "OPEN_SHELL";}
4049  public:
4050  std::string name; // label
4051  std::vector<StepID> cfs_faces; // face
4052 };
4053 
4054 StepEntity *step_create_open_shell(StepFileLine & line);
4055 
4057 {
4058  public:
4059  StepElementarySurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4060  virtual ~StepElementarySurface() {}
4061  virtual bool read(StepFileLine & line);
4062  virtual void write(std::ostream & os) const;
4063  virtual const char *keyString() const {return "ELEMENTARY_SURFACE";}
4064  public:
4065  std::string name; // label
4066  StepID position; // axis2_placement_3d
4067 };
4068 
4069 StepEntity *step_create_elementary_surface(StepFileLine & line);
4070 
4072 {
4073  public:
4074  StepPointOnCurve(StepID entityId=0) : StepEntity(entityId) , basis_curve(0) {}
4075  virtual ~StepPointOnCurve() {}
4076  virtual bool read(StepFileLine & line);
4077  virtual void write(std::ostream & os) const;
4078  virtual const char *keyString() const {return "POINT_ON_CURVE";}
4079  public:
4080  std::string name; // label
4081  StepID basis_curve; // curve
4082  double point_parameter; // parameter_value
4083 };
4084 
4085 StepEntity *step_create_point_on_curve(StepFileLine & line);
4086 
4088 {
4089  public:
4090  StepCurveReplica(StepID entityId=0) : StepEntity(entityId) , parent_curve(0), transformation(0) {}
4091  virtual ~StepCurveReplica() {}
4092  virtual bool read(StepFileLine & line);
4093  virtual void write(std::ostream & os) const;
4094  virtual const char *keyString() const {return "CURVE_REPLICA";}
4095  public:
4096  std::string name; // label
4097  StepID parent_curve; // curve
4098  StepID transformation; // cartesian_transformation_operator
4099 };
4100 
4101 StepEntity *step_create_curve_replica(StepFileLine & line);
4102 
4104 {
4105  public:
4106  StepVertexLoop(StepID entityId=0) : StepEntity(entityId) , loop_vertex(0) {}
4107  virtual ~StepVertexLoop() {}
4108  virtual bool read(StepFileLine & line);
4109  virtual void write(std::ostream & os) const;
4110  virtual const char *keyString() const {return "VERTEX_LOOP";}
4111  public:
4112  std::string name; // label
4113  StepID loop_vertex; // vertex
4114 };
4115 
4116 StepEntity *step_create_vertex_loop(StepFileLine & line);
4117 
4119 {
4120  public:
4121  StepVertexPoint(StepID entityId=0) : StepEntity(entityId) , vertex_geometry(0) {}
4122  virtual ~StepVertexPoint() {}
4123  virtual bool read(StepFileLine & line);
4124  virtual void write(std::ostream & os) const;
4125  virtual const char *keyString() const {return "VERTEX_POINT";}
4126  public:
4127  std::string name; // label
4128  StepID vertex_geometry; // point
4129 };
4130 
4131 StepEntity *step_create_vertex_point(StepFileLine & line);
4132 
4134 {
4135  public:
4136  StepSolidModel(StepID entityId=0) : StepEntity(entityId) {}
4137  virtual ~StepSolidModel() {}
4138  virtual bool read(StepFileLine & line);
4139  virtual void write(std::ostream & os) const;
4140  virtual const char *keyString() const {return "SOLID_MODEL";}
4141  public:
4142  std::string name; // label
4143 };
4144 
4145 StepEntity *step_create_solid_model(StepFileLine & line);
4146 
4148 {
4149  public:
4150  StepShellBasedWireframeModel(StepID entityId=0) : StepEntity(entityId) {}
4151  virtual ~StepShellBasedWireframeModel() {}
4152  virtual bool read(StepFileLine & line);
4153  virtual void write(std::ostream & os) const;
4154  virtual const char *keyString() const {return "SHELL_BASED_WIREFRAME_MODEL";}
4155  public:
4156  std::string name; // label
4157  std::vector<StepShell> sbwm_boundary; // shell
4158 };
4159 
4160 StepEntity *step_create_shell_based_wireframe_model(StepFileLine & line);
4161 
4163 {
4164  public:
4165  StepPlacement(StepID entityId=0) : StepEntity(entityId) , location(0) {}
4166  virtual ~StepPlacement() {}
4167  virtual bool read(StepFileLine & line);
4168  virtual void write(std::ostream & os) const;
4169  virtual const char *keyString() const {return "PLACEMENT";}
4170  public:
4171  std::string name; // label
4172  StepID location; // cartesian_point
4173 };
4174 
4175 StepEntity *step_create_placement(StepFileLine & line);
4176 
4178 {
4179  public:
4180  StepPointOnSurface(StepID entityId=0) : StepEntity(entityId) , basis_surface(0) {}
4181  virtual ~StepPointOnSurface() {}
4182  virtual bool read(StepFileLine & line);
4183  virtual void write(std::ostream & os) const;
4184  virtual const char *keyString() const {return "POINT_ON_SURFACE";}
4185  public:
4186  std::string name; // label
4187  StepID basis_surface; // surface
4188  double point_parameter_u; // parameter_value
4189  double point_parameter_v; // parameter_value
4190 };
4191 
4192 StepEntity *step_create_point_on_surface(StepFileLine & line);
4193 
4195 {
4196  public:
4197  StepCartesianPoint(StepID entityId=0) : StepEntity(entityId) {}
4198  virtual ~StepCartesianPoint() {}
4199  virtual bool read(StepFileLine & line);
4200  virtual void write(std::ostream & os) const;
4201  virtual const char *keyString() const {return "CARTESIAN_POINT";}
4202  public:
4203  std::string name; // label
4204  double coordinates[3]; // length_measure
4205 };
4206 
4207 StepEntity *step_create_cartesian_point(StepFileLine & line);
4208 
4209 class StepEdgeLoop : public StepEntity
4210 {
4211  public:
4212  StepEdgeLoop(StepID entityId=0) : StepEntity(entityId) {}
4213  virtual ~StepEdgeLoop() {}
4214  virtual bool read(StepFileLine & line);
4215  virtual void write(std::ostream & os) const;
4216  virtual const char *keyString() const {return "EDGE_LOOP";}
4217  public:
4218  std::string name; // label
4219  std::vector<StepID> edge_list; // oriented_edge
4220 };
4221 
4222 StepEntity *step_create_edge_loop(StepFileLine & line);
4223 
4224 class StepLine : public StepEntity
4225 {
4226  public:
4227  StepLine(StepID entityId=0) : StepEntity(entityId) , pnt(0), dir(0) {}
4228  virtual ~StepLine() {}
4229  virtual bool read(StepFileLine & line);
4230  virtual void write(std::ostream & os) const;
4231  virtual const char *keyString() const {return "LINE";}
4232  public:
4233  std::string name; // label
4234  StepID pnt; // cartesian_point
4235  StepID dir; // vector
4236 };
4237 
4238 StepEntity *step_create_line(StepFileLine & line);
4239 
4240 class StepConic : public StepEntity
4241 {
4242  public:
4243  StepConic(StepID entityId=0) : StepEntity(entityId) {}
4244  virtual ~StepConic() {}
4245  virtual bool read(StepFileLine & line);
4246  virtual void write(std::ostream & os) const;
4247  virtual const char *keyString() const {return "CONIC";}
4248  public:
4249  std::string name; // label
4250  StepAxis2Placement position; // axis2_placement
4251 };
4252 
4253 StepEntity *step_create_conic(StepFileLine & line);
4254 
4256 {
4257  public:
4258  StepFaceSurface(StepID entityId=0) : StepEntity(entityId) , face_geometry(0) {}
4259  virtual ~StepFaceSurface() {}
4260  virtual bool read(StepFileLine & line);
4261  virtual void write(std::ostream & os) const;
4262  virtual const char *keyString() const {return "FACE_SURFACE";}
4263  public:
4264  std::string name; // label
4265  std::vector<StepID> bounds; // face_bound
4266  StepID face_geometry; // surface
4267  bool same_sense; // BOOLEAN
4268 };
4269 
4270 StepEntity *step_create_face_surface(StepFileLine & line);
4271 
4273 {
4274  public:
4275  StepCartesianTransformationOperator(StepID entityId=0) : StepEntity(entityId) , axis1(0), axis2(0), local_origin(0) {}
4277  virtual bool read(StepFileLine & line);
4278  virtual void write(std::ostream & os) const;
4279  virtual const char *keyString() const {return "CARTESIAN_TRANSFORMATION_OPERATOR";}
4280  public:
4281  std::string name; // label
4282  StepID axis1; // direction
4283  StepID axis2; // direction
4284  StepID local_origin; // cartesian_point
4285  double scale; // REAL
4286 };
4287 
4288 StepEntity *step_create_cartesian_transformation_operator(StepFileLine & line);
4289 
4291 {
4292  public:
4293  StepPointReplica(StepID entityId=0) : StepEntity(entityId) , parent_pt(0), transformation(0) {}
4294  virtual ~StepPointReplica() {}
4295  virtual bool read(StepFileLine & line);
4296  virtual void write(std::ostream & os) const;
4297  virtual const char *keyString() const {return "POINT_REPLICA";}
4298  public:
4299  std::string name; // label
4300  StepID parent_pt; // point
4301  StepID transformation; // cartesian_transformation_operator
4302 };
4303 
4304 StepEntity *step_create_point_replica(StepFileLine & line);
4305 
4307 {
4308  public:
4309  StepManifoldSolidBrep(StepID entityId=0) : StepEntity(entityId) , outer(0) {}
4310  virtual ~StepManifoldSolidBrep() {}
4311  virtual bool read(StepFileLine & line);
4312  virtual void write(std::ostream & os) const;
4313  virtual const char *keyString() const {return "MANIFOLD_SOLID_BREP";}
4314  public:
4315  std::string name; // label
4316  StepID outer; // closed_shell
4317 };
4318 
4319 StepEntity *step_create_manifold_solid_brep(StepFileLine & line);
4320 
4322 {
4323  public:
4324  StepBrepWithVoids(StepID entityId=0) : StepEntity(entityId) , outer(0) {}
4325  virtual ~StepBrepWithVoids() {}
4326  virtual bool read(StepFileLine & line);
4327  virtual void write(std::ostream & os) const;
4328  virtual const char *keyString() const {return "BREP_WITH_VOIDS";}
4329  public:
4330  std::string name; // label
4331  StepID outer; // closed_shell
4332  std::vector<StepID> voids; // oriented_closed_shell
4333 };
4334 
4335 StepEntity *step_create_brep_with_voids(StepFileLine & line);
4336 
4338 {
4339  public:
4340  StepSurfaceCurve(StepID entityId=0) : StepEntity(entityId) , curve_3d(0) {}
4341  virtual ~StepSurfaceCurve() {}
4342  virtual bool read(StepFileLine & line);
4343  virtual void write(std::ostream & os) const;
4344  virtual const char *keyString() const {return "SURFACE_CURVE";}
4345  public:
4346  std::string name; // label
4347  StepID curve_3d; // curve
4348  StepPcurveOrSurface associated_geometry[2]; // pcurve_or_surface
4349  StepPreferredSurfaceCurveRepresentation master_representation; // preferred_surface_curve_representation
4350 };
4351 
4352 StepEntity *step_create_surface_curve(StepFileLine & line);
4353 
4355 {
4356  public:
4357  StepAxis2Placement3d(StepID entityId=0) : StepEntity(entityId) , location(0), axis(0), ref_direction(0) {}
4358  virtual ~StepAxis2Placement3d() {}
4359  virtual bool read(StepFileLine & line);
4360  virtual void write(std::ostream & os) const;
4361  virtual const char *keyString() const {return "AXIS2_PLACEMENT_3D";}
4362  public:
4363  std::string name; // label
4364  StepID location; // cartesian_point
4365  StepID axis; // direction
4366  StepID ref_direction; // direction
4367 };
4368 
4369 StepEntity *step_create_axis2_placement_3d(StepFileLine & line);
4370 
4372 {
4373  public:
4374  StepSurfaceReplica(StepID entityId=0) : StepEntity(entityId) , parent_surface(0), transformation(0) {}
4375  virtual ~StepSurfaceReplica() {}
4376  virtual bool read(StepFileLine & line);
4377  virtual void write(std::ostream & os) const;
4378  virtual const char *keyString() const {return "SURFACE_REPLICA";}
4379  public:
4380  std::string name; // label
4381  StepID parent_surface; // surface
4382  StepID transformation; // cartesian_transformation_operator_3d
4383 };
4384 
4385 StepEntity *step_create_surface_replica(StepFileLine & line);
4386 
4388 {
4389  public:
4390  StepHyperbola(StepID entityId=0) : StepEntity(entityId) {}
4391  virtual ~StepHyperbola() {}
4392  virtual bool read(StepFileLine & line);
4393  virtual void write(std::ostream & os) const;
4394  virtual const char *keyString() const {return "HYPERBOLA";}
4395  public:
4396  std::string name; // label
4397  StepAxis2Placement position; // axis2_placement
4398  double semi_axis; // positive_length_measure
4399  double semi_imag_axis; // positive_length_measure
4400 };
4401 
4402 StepEntity *step_create_hyperbola(StepFileLine & line);
4403 
4405 {
4406  public:
4407  StepBoundedSurface(StepID entityId=0) : StepEntity(entityId) {}
4408  virtual ~StepBoundedSurface() {}
4409  virtual bool read(StepFileLine & line);
4410  virtual void write(std::ostream & os) const;
4411  virtual const char *keyString() const {return "BOUNDED_SURFACE";}
4412  public:
4413  std::string name; // label
4414 };
4415 
4416 StepEntity *step_create_bounded_surface(StepFileLine & line);
4417 
4418 class StepPlane : public StepEntity
4419 {
4420  public:
4421  StepPlane(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4422  virtual ~StepPlane() {}
4423  virtual bool read(StepFileLine & line);
4424  virtual void write(std::ostream & os) const;
4425  virtual const char *keyString() const {return "PLANE";}
4426  public:
4427  std::string name; // label
4428  StepID position; // axis2_placement_3d
4429 };
4430 
4431 StepEntity *step_create_plane(StepFileLine & line);
4432 
4434 {
4435  public:
4436  StepEdgeBasedWireframeModel(StepID entityId=0) : StepEntity(entityId) {}
4437  virtual ~StepEdgeBasedWireframeModel() {}
4438  virtual bool read(StepFileLine & line);
4439  virtual void write(std::ostream & os) const;
4440  virtual const char *keyString() const {return "EDGE_BASED_WIREFRAME_MODEL";}
4441  public:
4442  std::string name; // label
4443  std::vector<StepID> ebwm_boundary; // connected_edge_set
4444 };
4445 
4446 StepEntity *step_create_edge_based_wireframe_model(StepFileLine & line);
4447 
4449 {
4450  public:
4451  StepEdgeCurve(StepID entityId=0) : StepEntity(entityId) , edge_start(0), edge_end(0), edge_geometry(0) {}
4452  virtual ~StepEdgeCurve() {}
4453  virtual bool read(StepFileLine & line);
4454  virtual void write(std::ostream & os) const;
4455  virtual const char *keyString() const {return "EDGE_CURVE";}
4456  public:
4457  std::string name; // label
4458  StepID edge_start; // vertex
4459  StepID edge_end; // vertex
4460  StepID edge_geometry; // curve
4461  bool same_sense; // BOOLEAN
4462 };
4463 
4464 StepEntity *step_create_edge_curve(StepFileLine & line);
4465 
4466 class StepParabola : public StepEntity
4467 {
4468  public:
4469  StepParabola(StepID entityId=0) : StepEntity(entityId) {}
4470  virtual ~StepParabola() {}
4471  virtual bool read(StepFileLine & line);
4472  virtual void write(std::ostream & os) const;
4473  virtual const char *keyString() const {return "PARABOLA";}
4474  public:
4475  std::string name; // label
4476  StepAxis2Placement position; // axis2_placement
4477  double focal_dist; // length_measure
4478 };
4479 
4480 StepEntity *step_create_parabola(StepFileLine & line);
4481 
4483 {
4484  public:
4485  StepOffsetCurve3d(StepID entityId=0) : StepEntity(entityId) , basis_curve(0), ref_direction(0) {}
4486  virtual ~StepOffsetCurve3d() {}
4487  virtual bool read(StepFileLine & line);
4488  virtual void write(std::ostream & os) const;
4489  virtual const char *keyString() const {return "OFFSET_CURVE_3D";}
4490  public:
4491  std::string name; // label
4492  StepID basis_curve; // curve
4493  double distance; // length_measure
4494  StepLogical self_intersect; // LOGICAL
4495  StepID ref_direction; // direction
4496 };
4497 
4498 StepEntity *step_create_offset_curve_3d(StepFileLine & line);
4499 
4501 {
4502  public:
4503  StepSphericalSurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4504  virtual ~StepSphericalSurface() {}
4505  virtual bool read(StepFileLine & line);
4506  virtual void write(std::ostream & os) const;
4507  virtual const char *keyString() const {return "SPHERICAL_SURFACE";}
4508  public:
4509  std::string name; // label
4510  StepID position; // axis2_placement_3d
4511  double radius; // positive_length_measure
4512 };
4513 
4514 StepEntity *step_create_spherical_surface(StepFileLine & line);
4515 
4517 {
4518  public:
4519  StepDegeneratePcurve(StepID entityId=0) : StepEntity(entityId) , basis_surface(0), reference_to_curve(0) {}
4520  virtual ~StepDegeneratePcurve() {}
4521  virtual bool read(StepFileLine & line);
4522  virtual void write(std::ostream & os) const;
4523  virtual const char *keyString() const {return "DEGENERATE_PCURVE";}
4524  public:
4525  std::string name; // label
4526  StepID basis_surface; // surface
4527  StepID reference_to_curve; // definitional_representation
4528 };
4529 
4530 StepEntity *step_create_degenerate_pcurve(StepFileLine & line);
4531 
4533 {
4534  public:
4535  StepBSplineSurface(StepID entityId=0) : StepEntity(entityId) {}
4536  virtual ~StepBSplineSurface() {}
4537  virtual bool read(StepFileLine & line);
4538  virtual void write(std::ostream & os) const;
4539  virtual const char *keyString() const {return "B_SPLINE_SURFACE";}
4540  public:
4541  std::string name; // label
4542  int u_degree; // INTEGER
4543  int v_degree; // INTEGER
4544  DMatrix<StepID> control_points_list; // cartesian_point
4545  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
4546  StepLogical u_closed; // LOGICAL
4547  StepLogical v_closed; // LOGICAL
4548  StepLogical self_intersect; // LOGICAL
4549 };
4550 
4551 StepEntity *step_create_b_spline_surface(StepFileLine & line);
4552 
4554 {
4555  public:
4556  StepCurveBoundedSurface(StepID entityId=0) : StepEntity(entityId) , basis_surface(0) {}
4557  virtual ~StepCurveBoundedSurface() {}
4558  virtual bool read(StepFileLine & line);
4559  virtual void write(std::ostream & os) const;
4560  virtual const char *keyString() const {return "CURVE_BOUNDED_SURFACE";}
4561  public:
4562  std::string name; // label
4563  StepID basis_surface; // surface
4564  std::vector<StepID> boundaries; // boundary_curve
4565  bool implicit_outer; // BOOLEAN
4566 };
4567 
4568 StepEntity *step_create_curve_bounded_surface(StepFileLine & line);
4569 
4571 {
4572  public:
4573  StepRectangularCompositeSurface(StepID entityId=0) : StepEntity(entityId) {}
4574  virtual ~StepRectangularCompositeSurface() {}
4575  virtual bool read(StepFileLine & line);
4576  virtual void write(std::ostream & os) const;
4577  virtual const char *keyString() const {return "RECTANGULAR_COMPOSITE_SURFACE";}
4578  public:
4579  std::string name; // label
4580  DMatrix<StepID> segments; // surface_patch
4581 };
4582 
4583 StepEntity *step_create_rectangular_composite_surface(StepFileLine & line);
4584 
4585 class StepEllipse : public StepEntity
4586 {
4587  public:
4588  StepEllipse(StepID entityId=0) : StepEntity(entityId) {}
4589  virtual ~StepEllipse() {}
4590  virtual bool read(StepFileLine & line);
4591  virtual void write(std::ostream & os) const;
4592  virtual const char *keyString() const {return "ELLIPSE";}
4593  public:
4594  std::string name; // label
4595  StepAxis2Placement position; // axis2_placement
4596  double semi_axis_1; // positive_length_measure
4597  double semi_axis_2; // positive_length_measure
4598 };
4599 
4600 StepEntity *step_create_ellipse(StepFileLine & line);
4601 
4603 {
4604  public:
4605  StepRationalBSplineSurface(StepID entityId=0) : StepEntity(entityId) {}
4606  virtual ~StepRationalBSplineSurface() {}
4607  virtual bool read(StepFileLine & line);
4608  virtual void write(std::ostream & os) const;
4609  virtual const char *keyString() const {return "RATIONAL_B_SPLINE_SURFACE";}
4610  public:
4611  std::string name; // label
4612  int u_degree; // INTEGER
4613  int v_degree; // INTEGER
4614  DMatrix<StepID> control_points_list; // cartesian_point
4615  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
4616  StepLogical u_closed; // LOGICAL
4617  StepLogical v_closed; // LOGICAL
4618  StepLogical self_intersect; // LOGICAL
4619  DMatrix<double> weights_data; // REAL
4620 };
4621 
4622 StepEntity *step_create_rational_b_spline_surface(StepFileLine & line);
4623 
4625 {
4626  public:
4627  StepSweptSurface(StepID entityId=0) : StepEntity(entityId) , swept_curve(0) {}
4628  virtual ~StepSweptSurface() {}
4629  virtual bool read(StepFileLine & line);
4630  virtual void write(std::ostream & os) const;
4631  virtual const char *keyString() const {return "SWEPT_SURFACE";}
4632  public:
4633  std::string name; // label
4634  StepID swept_curve; // curve
4635 };
4636 
4637 StepEntity *step_create_swept_surface(StepFileLine & line);
4638 
4640 {
4641  public:
4642  StepAxis2Placement2d(StepID entityId=0) : StepEntity(entityId) , location(0), ref_direction(0) {}
4643  virtual ~StepAxis2Placement2d() {}
4644  virtual bool read(StepFileLine & line);
4645  virtual void write(std::ostream & os) const;
4646  virtual const char *keyString() const {return "AXIS2_PLACEMENT_2D";}
4647  public:
4648  std::string name; // label
4649  StepID location; // cartesian_point
4650  StepID ref_direction; // direction
4651 };
4652 
4653 StepEntity *step_create_axis2_placement_2d(StepFileLine & line);
4654 
4656 {
4657  public:
4658  StepConicalSurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4659  virtual ~StepConicalSurface() {}
4660  virtual bool read(StepFileLine & line);
4661  virtual void write(std::ostream & os) const;
4662  virtual const char *keyString() const {return "CONICAL_SURFACE";}
4663  public:
4664  std::string name; // label
4665  StepID position; // axis2_placement_3d
4666  double radius; // length_measure
4667  double semi_angle; // plane_angle_measure
4668 };
4669 
4670 StepEntity *step_create_conical_surface(StepFileLine & line);
4671 
4673 {
4674  public:
4675  StepOffsetSurface(StepID entityId=0) : StepEntity(entityId) , basis_surface(0) {}
4676  virtual ~StepOffsetSurface() {}
4677  virtual bool read(StepFileLine & line);
4678  virtual void write(std::ostream & os) const;
4679  virtual const char *keyString() const {return "OFFSET_SURFACE";}
4680  public:
4681  std::string name; // label
4682  StepID basis_surface; // surface
4683  double distance; // length_measure
4684  StepLogical self_intersect; // LOGICAL
4685 };
4686 
4687 StepEntity *step_create_offset_surface(StepFileLine & line);
4688 
4690 {
4691  public:
4692  StepFacetedBrep(StepID entityId=0) : StepEntity(entityId) , outer(0) {}
4693  virtual ~StepFacetedBrep() {}
4694  virtual bool read(StepFileLine & line);
4695  virtual void write(std::ostream & os) const;
4696  virtual const char *keyString() const {return "FACETED_BREP";}
4697  public:
4698  std::string name; // label
4699  StepID outer; // closed_shell
4700 };
4701 
4702 StepEntity *step_create_faceted_brep(StepFileLine & line);
4703 
4705 {
4706  public:
4707  StepSurfaceOfRevolution(StepID entityId=0) : StepEntity(entityId) , swept_curve(0), axis_position(0) {}
4708  virtual ~StepSurfaceOfRevolution() {}
4709  virtual bool read(StepFileLine & line);
4710  virtual void write(std::ostream & os) const;
4711  virtual const char *keyString() const {return "SURFACE_OF_REVOLUTION";}
4712  public:
4713  std::string name; // label
4714  StepID swept_curve; // curve
4715  StepID axis_position; // axis1_placement
4716 };
4717 
4718 StepEntity *step_create_surface_of_revolution(StepFileLine & line);
4719 
4721 {
4722  public:
4723  StepSurfaceOfLinearExtrusion(StepID entityId=0) : StepEntity(entityId) , swept_curve(0), extrusion_axis(0) {}
4724  virtual ~StepSurfaceOfLinearExtrusion() {}
4725  virtual bool read(StepFileLine & line);
4726  virtual void write(std::ostream & os) const;
4727  virtual const char *keyString() const {return "SURFACE_OF_LINEAR_EXTRUSION";}
4728  public:
4729  std::string name; // label
4730  StepID swept_curve; // curve
4731  StepID extrusion_axis; // vector
4732 };
4733 
4734 StepEntity *step_create_surface_of_linear_extrusion(StepFileLine & line);
4735 
4736 class StepPcurve : public StepEntity
4737 {
4738  public:
4739  StepPcurve(StepID entityId=0) : StepEntity(entityId) , basis_surface(0), reference_to_curve(0) {}
4740  virtual ~StepPcurve() {}
4741  virtual bool read(StepFileLine & line);
4742  virtual void write(std::ostream & os) const;
4743  virtual const char *keyString() const {return "PCURVE";}
4744  public:
4745  std::string name; // label
4746  StepID basis_surface; // surface
4747  StepID reference_to_curve; // definitional_representation
4748 };
4749 
4750 StepEntity *step_create_pcurve(StepFileLine & line);
4751 
4753 {
4754  public:
4755  StepUniformSurface(StepID entityId=0) : StepEntity(entityId) {}
4756  virtual ~StepUniformSurface() {}
4757  virtual bool read(StepFileLine & line);
4758  virtual void write(std::ostream & os) const;
4759  virtual const char *keyString() const {return "UNIFORM_SURFACE";}
4760  public:
4761  std::string name; // label
4762  int u_degree; // INTEGER
4763  int v_degree; // INTEGER
4764  DMatrix<StepID> control_points_list; // cartesian_point
4765  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
4766  StepLogical u_closed; // LOGICAL
4767  StepLogical v_closed; // LOGICAL
4768  StepLogical self_intersect; // LOGICAL
4769 };
4770 
4771 StepEntity *step_create_uniform_surface(StepFileLine & line);
4772 
4774 {
4775  public:
4776  StepBoundedCurve(StepID entityId=0) : StepEntity(entityId) {}
4777  virtual ~StepBoundedCurve() {}
4778  virtual bool read(StepFileLine & line);
4779  virtual void write(std::ostream & os) const;
4780  virtual const char *keyString() const {return "BOUNDED_CURVE";}
4781  public:
4782  std::string name; // label
4783 };
4784 
4785 StepEntity *step_create_bounded_curve(StepFileLine & line);
4786 
4788 {
4789  public:
4790  StepQuasiUniformSurface(StepID entityId=0) : StepEntity(entityId) {}
4791  virtual ~StepQuasiUniformSurface() {}
4792  virtual bool read(StepFileLine & line);
4793  virtual void write(std::ostream & os) const;
4794  virtual const char *keyString() const {return "QUASI_UNIFORM_SURFACE";}
4795  public:
4796  std::string name; // label
4797  int u_degree; // INTEGER
4798  int v_degree; // INTEGER
4799  DMatrix<StepID> control_points_list; // cartesian_point
4800  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
4801  StepLogical u_closed; // LOGICAL
4802  StepLogical v_closed; // LOGICAL
4803  StepLogical self_intersect; // LOGICAL
4804 };
4805 
4806 StepEntity *step_create_quasi_uniform_surface(StepFileLine & line);
4807 
4809 {
4810  public:
4811  StepToroidalSurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4812  virtual ~StepToroidalSurface() {}
4813  virtual bool read(StepFileLine & line);
4814  virtual void write(std::ostream & os) const;
4815  virtual const char *keyString() const {return "TOROIDAL_SURFACE";}
4816  public:
4817  std::string name; // label
4818  StepID position; // axis2_placement_3d
4819  double major_radius; // positive_length_measure
4820  double minor_radius; // positive_length_measure
4821 };
4822 
4823 StepEntity *step_create_toroidal_surface(StepFileLine & line);
4824 
4826 {
4827  public:
4828  StepOrientedOpenShell(StepID entityId=0) : StepEntity(entityId) , open_shell_element(0) {}
4829  virtual ~StepOrientedOpenShell() {}
4830  virtual bool read(StepFileLine & line);
4831  virtual void write(std::ostream & os) const;
4832  virtual const char *keyString() const {return "ORIENTED_OPEN_SHELL";}
4833  public:
4834  std::string name; // label
4835  std::vector<StepID> cfs_faces; // face
4836  StepID open_shell_element; // open_shell
4837  bool orientation; // BOOLEAN
4838 };
4839 
4840 StepEntity *step_create_oriented_open_shell(StepFileLine & line);
4841 
4843 {
4844  public:
4845  StepCylindricalSurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4846  virtual ~StepCylindricalSurface() {}
4847  virtual bool read(StepFileLine & line);
4848  virtual void write(std::ostream & os) const;
4849  virtual const char *keyString() const {return "CYLINDRICAL_SURFACE";}
4850  public:
4851  std::string name; // label
4852  StepID position; // axis2_placement_3d
4853  double radius; // positive_length_measure
4854 };
4855 
4856 StepEntity *step_create_cylindrical_surface(StepFileLine & line);
4857 
4859 {
4860  public:
4861  StepIntersectionCurve(StepID entityId=0) : StepEntity(entityId) , curve_3d(0) {}
4862  virtual ~StepIntersectionCurve() {}
4863  virtual bool read(StepFileLine & line);
4864  virtual void write(std::ostream & os) const;
4865  virtual const char *keyString() const {return "INTERSECTION_CURVE";}
4866  public:
4867  std::string name; // label
4868  StepID curve_3d; // curve
4869  StepPcurveOrSurface associated_geometry[2]; // pcurve_or_surface
4870  StepPreferredSurfaceCurveRepresentation master_representation; // preferred_surface_curve_representation
4871 };
4872 
4873 StepEntity *step_create_intersection_curve(StepFileLine & line);
4874 
4876 {
4877  public:
4878  StepRectangularTrimmedSurface(StepID entityId=0) : StepEntity(entityId) , basis_surface(0) {}
4879  virtual ~StepRectangularTrimmedSurface() {}
4880  virtual bool read(StepFileLine & line);
4881  virtual void write(std::ostream & os) const;
4882  virtual const char *keyString() const {return "RECTANGULAR_TRIMMED_SURFACE";}
4883  public:
4884  std::string name; // label
4885  StepID basis_surface; // surface
4886  double u1; // parameter_value
4887  double u2; // parameter_value
4888  double v1; // parameter_value
4889  double v2; // parameter_value
4890  bool usense; // BOOLEAN
4891  bool vsense; // BOOLEAN
4892 };
4893 
4894 StepEntity *step_create_rectangular_trimmed_surface(StepFileLine & line);
4895 
4897 {
4898  public:
4899  StepSeamCurve(StepID entityId=0) : StepEntity(entityId) , curve_3d(0) {}
4900  virtual ~StepSeamCurve() {}
4901  virtual bool read(StepFileLine & line);
4902  virtual void write(std::ostream & os) const;
4903  virtual const char *keyString() const {return "SEAM_CURVE";}
4904  public:
4905  std::string name; // label
4906  StepID curve_3d; // curve
4907  StepPcurveOrSurface associated_geometry[2]; // pcurve_or_surface
4908  StepPreferredSurfaceCurveRepresentation master_representation; // preferred_surface_curve_representation
4909 };
4910 
4911 StepEntity *step_create_seam_curve(StepFileLine & line);
4912 
4914 {
4915  public:
4916  StepAdvancedFace(StepID entityId=0) : StepEntity(entityId) , face_geometry(0) {}
4917  virtual ~StepAdvancedFace() {}
4918  virtual bool read(StepFileLine & line);
4919  virtual void write(std::ostream & os) const;
4920  virtual const char *keyString() const {return "ADVANCED_FACE";}
4921  public:
4922  std::string name; // label
4923  std::vector<StepID> bounds; // face_bound
4924  StepID face_geometry; // surface
4925  bool same_sense; // BOOLEAN
4926 };
4927 
4928 StepEntity *step_create_advanced_face(StepFileLine & line);
4929 
4931 {
4932  public:
4933  StepDegenerateToroidalSurface(StepID entityId=0) : StepEntity(entityId) , position(0) {}
4934  virtual ~StepDegenerateToroidalSurface() {}
4935  virtual bool read(StepFileLine & line);
4936  virtual void write(std::ostream & os) const;
4937  virtual const char *keyString() const {return "DEGENERATE_TOROIDAL_SURFACE";}
4938  public:
4939  std::string name; // label
4940  StepID position; // axis2_placement_3d
4941  double major_radius; // positive_length_measure
4942  double minor_radius; // positive_length_measure
4943  bool select_outer; // BOOLEAN
4944 };
4945 
4946 StepEntity *step_create_degenerate_toroidal_surface(StepFileLine & line);
4947 
4948 class StepPolyline : public StepEntity
4949 {
4950  public:
4951  StepPolyline(StepID entityId=0) : StepEntity(entityId) {}
4952  virtual ~StepPolyline() {}
4953  virtual bool read(StepFileLine & line);
4954  virtual void write(std::ostream & os) const;
4955  virtual const char *keyString() const {return "POLYLINE";}
4956  public:
4957  std::string name; // label
4958  std::vector<StepID> points; // cartesian_point
4959 };
4960 
4961 StepEntity *step_create_polyline(StepFileLine & line);
4962 
4963 class StepCircle : public StepEntity
4964 {
4965  public:
4966  StepCircle(StepID entityId=0) : StepEntity(entityId) {}
4967  virtual ~StepCircle() {}
4968  virtual bool read(StepFileLine & line);
4969  virtual void write(std::ostream & os) const;
4970  virtual const char *keyString() const {return "CIRCLE";}
4971  public:
4972  std::string name; // label
4973  StepAxis2Placement position; // axis2_placement
4974  double radius; // positive_length_measure
4975 };
4976 
4977 StepEntity *step_create_circle(StepFileLine & line);
4978 
4980 {
4981  public:
4982  StepBoundedSurfaceCurve(StepID entityId=0) : StepEntity(entityId) , curve_3d(0) {}
4983  virtual ~StepBoundedSurfaceCurve() {}
4984  virtual bool read(StepFileLine & line);
4985  virtual void write(std::ostream & os) const;
4986  virtual const char *keyString() const {return "BOUNDED_SURFACE_CURVE";}
4987  public:
4988  std::string name; // label
4989  StepID curve_3d; // curve
4990  StepPcurveOrSurface associated_geometry[2]; // pcurve_or_surface
4991  StepPreferredSurfaceCurveRepresentation master_representation; // preferred_surface_curve_representation
4992 };
4993 
4994 StepEntity *step_create_bounded_surface_curve(StepFileLine & line);
4995 
4997 {
4998  public:
4999  StepAxis1Placement(StepID entityId=0) : StepEntity(entityId) , location(0), axis(0) {}
5000  virtual ~StepAxis1Placement() {}
5001  virtual bool read(StepFileLine & line);
5002  virtual void write(std::ostream & os) const;
5003  virtual const char *keyString() const {return "AXIS1_PLACEMENT";}
5004  public:
5005  std::string name; // label
5006  StepID location; // cartesian_point
5007  StepID axis; // direction
5008 };
5009 
5010 StepEntity *step_create_axis1_placement(StepFileLine & line);
5011 
5013 {
5014  public:
5015  StepCartesianTransformationOperator3d(StepID entityId=0) : StepEntity(entityId) , axis1(0), axis2(0), local_origin(0), axis3(0) {}
5017  virtual bool read(StepFileLine & line);
5018  virtual void write(std::ostream & os) const;
5019  virtual const char *keyString() const {return "CARTESIAN_TRANSFORMATION_OPERATOR_3D";}
5020  public:
5021  std::string name; // label
5022  StepID axis1; // direction
5023  StepID axis2; // direction
5024  StepID local_origin; // cartesian_point
5025  double scale; // REAL
5026  StepID axis3; // direction
5027 };
5028 
5029 StepEntity *step_create_cartesian_transformation_operator_3d(StepFileLine & line);
5030 
5032 {
5033  public:
5034  StepEvaluatedDegeneratePcurve(StepID entityId=0) : StepEntity(entityId) , basis_surface(0), reference_to_curve(0), equivalent_point(0) {}
5035  virtual ~StepEvaluatedDegeneratePcurve() {}
5036  virtual bool read(StepFileLine & line);
5037  virtual void write(std::ostream & os) const;
5038  virtual const char *keyString() const {return "EVALUATED_DEGENERATE_PCURVE";}
5039  public:
5040  std::string name; // label
5041  StepID basis_surface; // surface
5042  StepID reference_to_curve; // definitional_representation
5043  StepID equivalent_point; // cartesian_point
5044 };
5045 
5046 StepEntity *step_create_evaluated_degenerate_pcurve(StepFileLine & line);
5047 
5049 {
5050  public:
5051  StepBezierSurface(StepID entityId=0) : StepEntity(entityId) {}
5052  virtual ~StepBezierSurface() {}
5053  virtual bool read(StepFileLine & line);
5054  virtual void write(std::ostream & os) const;
5055  virtual const char *keyString() const {return "BEZIER_SURFACE";}
5056  public:
5057  std::string name; // label
5058  int u_degree; // INTEGER
5059  int v_degree; // INTEGER
5060  DMatrix<StepID> control_points_list; // cartesian_point
5061  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
5062  StepLogical u_closed; // LOGICAL
5063  StepLogical v_closed; // LOGICAL
5064  StepLogical self_intersect; // LOGICAL
5065 };
5066 
5067 StepEntity *step_create_bezier_surface(StepFileLine & line);
5068 
5070 {
5071  public:
5072  StepBSplineSurfaceWithKnots(StepID entityId=0) : StepEntity(entityId) {}
5073  virtual ~StepBSplineSurfaceWithKnots() {}
5074  virtual bool read(StepFileLine & line);
5075  virtual void write(std::ostream & os) const;
5076  virtual const char *keyString() const {return "B_SPLINE_SURFACE_WITH_KNOTS";}
5077  public:
5078  std::string name; // label
5079  int u_degree; // INTEGER
5080  int v_degree; // INTEGER
5081  DMatrix<StepID> control_points_list; // cartesian_point
5082  StepBSplineSurfaceForm surface_form; // b_spline_surface_form
5083  StepLogical u_closed; // LOGICAL
5084  StepLogical v_closed; // LOGICAL
5085  StepLogical self_intersect; // LOGICAL
5086  std::vector<int> u_multiplicities; // INTEGER
5087  std::vector<int> v_multiplicities; // INTEGER
5088  std::vector<double> u_knots; // parameter_value
5089  std::vector<double> v_knots; // parameter_value
5090  StepKnotType knot_spec; // knot_type
5091 };
5092 
5093 StepEntity *step_create_b_spline_surface_with_knots(StepFileLine & line);
5094 
5096 {
5097  public:
5098  StepBSplineCurve(StepID entityId=0) : StepEntity(entityId) {}
5099  virtual ~StepBSplineCurve() {}
5100  virtual bool read(StepFileLine & line);
5101  virtual void write(std::ostream & os) const;
5102  virtual const char *keyString() const {return "B_SPLINE_CURVE";}
5103  public:
5104  std::string name; // label
5105  int degree; // INTEGER
5106  std::vector<StepID> control_points_list; // cartesian_point
5107  StepBSplineCurveForm curve_form; // b_spline_curve_form
5108  StepLogical closed_curve; // LOGICAL
5109  StepLogical self_intersect; // LOGICAL
5110 };
5111 
5112 StepEntity *step_create_b_spline_curve(StepFileLine & line);
5113 
5115 {
5116  public:
5117  StepTrimmedCurve(StepID entityId=0) : StepEntity(entityId) , basis_curve(0) {}
5118  virtual ~StepTrimmedCurve() {}
5119  virtual bool read(StepFileLine & line);
5120  virtual void write(std::ostream & os) const;
5121  virtual const char *keyString() const {return "TRIMMED_CURVE";}
5122  public:
5123  std::string name; // label
5124  StepID basis_curve; // curve
5125  StepTrimmingSelect trim_1[2]; // trimming_select
5126  StepTrimmingSelect trim_2[2]; // trimming_select
5127  bool sense_agreement; // BOOLEAN
5128  StepTrimmingPreference master_representation; // trimming_preference
5129 };
5130 
5131 StepEntity *step_create_trimmed_curve(StepFileLine & line);
5132 
5134 {
5135  public:
5136