(* This is a MODIFIED version of AP203 Amd. 1.

The change was to remove a useless IF...ELSE...ENDIF statement that always evaluated

the same way. Statements in the branch that was never executed caused problems with

libexpress, and it was easier to modify the schema than to come up with a generic

fix for libexpress. This change does *not* affect the behavior of the schema.

Based on:

AIM long form for ISO 10303-203 amendment 1

ISO TC184/SC4/WG3 N916

Larry McKee

2000-05-04

*)

SCHEMA config_control_design;

CONSTANT

dummy_gri : geometric_representation_item := representation_item('') ||

geometric_representation_item();

dummy_tri : topological_representation_item := representation_item('')

|| topological_representation_item();

END_CONSTANT;

TYPE ahead_or_behind = ENUMERATION OF

(ahead,

behind);

END_TYPE; -- ahead_or_behind

TYPE approved_item = SELECT

(product_definition_formation,

product_definition,

configuration_effectivity,

configuration_item,

security_classification,

change_request,

change,

start_request,

start_work,

certification,

contract);

END_TYPE; -- approved_item

TYPE area_measure = REAL;

END_TYPE; -- area_measure

TYPE axis2_placement = SELECT

(axis2_placement_2d,

axis2_placement_3d);

END_TYPE; -- axis2_placement

TYPE b_spline_curve_form = ENUMERATION OF

(polyline_form,

circular_arc,

elliptic_arc,

parabolic_arc,

hyperbolic_arc,

unspecified);

END_TYPE; -- b_spline_curve_form

TYPE b_spline_surface_form = ENUMERATION OF

(plane_surf,

cylindrical_surf,

conical_surf,

spherical_surf,

toroidal_surf,

surf_of_revolution,

ruled_surf,

generalised_cone,

quadric_surf,

surf_of_linear_extrusion,

unspecified);

END_TYPE; -- b_spline_surface_form

TYPE boolean_operand = SELECT

(solid_model);

END_TYPE; -- boolean_operand

TYPE certified_item = SELECT

(supplied_part_relationship);

END_TYPE; -- certified_item

TYPE change_request_item = SELECT

(product_definition_formation);

END_TYPE; -- change_request_item

TYPE characterized_definition = SELECT

(characterized_product_definition,

shape_definition);

END_TYPE; -- characterized_definition

TYPE characterized_product_definition = SELECT

(product_definition,

product_definition_relationship);

END_TYPE; -- characterized_product_definition

TYPE classified_item = SELECT

(product_definition_formation,

assembly_component_usage);

END_TYPE; -- classified_item

TYPE context_dependent_measure = REAL;

END_TYPE; -- context_dependent_measure

TYPE contracted_item = SELECT

(product_definition_formation);

END_TYPE; -- contracted_item

TYPE count_measure = NUMBER;

END_TYPE; -- count_measure

TYPE curve_on_surface = SELECT

(pcurve,

surface_curve,

composite_curve_on_surface);

END_TYPE; -- curve_on_surface

TYPE date_time_item = SELECT

(product_definition,

change_request,

start_request,

change,

start_work,

approval_person_organization,

contract,

security_classification,

certification);

END_TYPE; -- date_time_item

TYPE date_time_select = SELECT

(date,

local_time,

date_and_time);

END_TYPE; -- date_time_select

TYPE day_in_month_number = INTEGER;

END_TYPE; -- day_in_month_number

TYPE day_in_week_number = INTEGER;

WHERE

wr1: ((1 <= SELF) AND (SELF <= 7));

END_TYPE; -- day_in_week_number

TYPE day_in_year_number = INTEGER;

END_TYPE; -- day_in_year_number

TYPE descriptive_measure = STRING;

END_TYPE; -- descriptive_measure

TYPE dimension_count = INTEGER;

WHERE

wr1: (SELF > 0);

END_TYPE; -- dimension_count

TYPE founded_item_select = SELECT

(founded_item,

representation_item);

END_TYPE; -- founded_item_select

TYPE geometric_set_select = SELECT

(point,

curve,

surface);

END_TYPE; -- geometric_set_select

TYPE hour_in_day = INTEGER;

WHERE

wr1: ((0 <= SELF) AND (SELF < 24));

END_TYPE; -- hour_in_day

TYPE identifier = STRING;

END_TYPE; -- identifier

TYPE knot_type = ENUMERATION OF

(uniform_knots,

unspecified,

quasi_uniform_knots,

piecewise_bezier_knots);

END_TYPE; -- knot_type

TYPE label = STRING;

END_TYPE; -- label

TYPE length_measure = REAL;

END_TYPE; -- length_measure

TYPE list_of_reversible_topology_item = LIST [0:?] OF

reversible_topology_item;

END_TYPE; -- list_of_reversible_topology_item

TYPE mass_measure = REAL;

END_TYPE; -- mass_measure

TYPE measure_value = SELECT

(length_measure,

mass_measure,

plane_angle_measure,

solid_angle_measure,

area_measure,

volume_measure,

parameter_value,

context_dependent_measure,

descriptive_measure,

positive_length_measure,

positive_plane_angle_measure,

count_measure);

END_TYPE; -- measure_value

TYPE minute_in_hour = INTEGER;

WHERE

wr1: ((0 <= SELF) AND (SELF <= 59));

END_TYPE; -- minute_in_hour

TYPE month_in_year_number = INTEGER;

WHERE

wr1: ((1 <= SELF) AND (SELF <= 12));

END_TYPE; -- month_in_year_number

TYPE parameter_value = REAL;

END_TYPE; -- parameter_value

TYPE pcurve_or_surface = SELECT

(pcurve,

surface);

END_TYPE; -- pcurve_or_surface

TYPE person_organization_item = SELECT

(change,

start_work,

change_request,

start_request,

configuration_item,

product,

product_definition_formation,

product_definition,

contract,

security_classification);

END_TYPE; -- person_organization_item

TYPE person_organization_select = SELECT

(person,

organization,

person_and_organization);

END_TYPE; -- person_organization_select

TYPE plane_angle_measure = REAL;

END_TYPE; -- plane_angle_measure

TYPE positive_length_measure = length_measure;

WHERE

wr1: (SELF > 0);

END_TYPE; -- positive_length_measure

TYPE positive_plane_angle_measure = plane_angle_measure;

WHERE

wr1: (SELF > 0);

END_TYPE; -- positive_plane_angle_measure

TYPE preferred_surface_curve_representation = ENUMERATION OF

(curve_3d,

pcurve_s1,

pcurve_s2);

END_TYPE; -- preferred_surface_curve_representation

TYPE reversible_topology = SELECT

(reversible_topology_item,

list_of_reversible_topology_item,

set_of_reversible_topology_item);

END_TYPE; -- reversible_topology

TYPE reversible_topology_item = SELECT

(edge,

path,

face,

face_bound,

closed_shell,

open_shell);

END_TYPE; -- reversible_topology_item

TYPE second_in_minute = REAL;

WHERE

wr1: ((0 <= SELF) AND (SELF < 60));

END_TYPE; -- second_in_minute

TYPE set_of_reversible_topology_item = SET [0:?] OF

reversible_topology_item;

END_TYPE; -- set_of_reversible_topology_item

TYPE shape_definition = SELECT

(product_definition_shape,

shape_aspect,

shape_aspect_relationship);

END_TYPE; -- shape_definition

TYPE shell = SELECT

(vertex_shell,

wire_shell,

open_shell,

closed_shell);

END_TYPE; -- shell

TYPE si_prefix = ENUMERATION OF

(exa,

peta,

tera,

giga,

mega,

kilo,

hecto,

deca,

deci,

centi,

milli,

micro,

nano,

pico,

femto,

atto);

END_TYPE; -- si_prefix

TYPE si_unit_name = ENUMERATION OF

(metre,

gram,

second,

ampere,

kelvin,

mole,

candela,

radian,

steradian,

hertz,

newton,

pascal,

joule,

watt,

coulomb,

volt,

farad,

ohm,

siemens,

weber,

tesla,

henry,

degree_celsius,

lumen,

lux,

becquerel,

gray,

sievert);

END_TYPE; -- si_unit_name

TYPE solid_angle_measure = REAL;

END_TYPE; -- solid_angle_measure

TYPE source = ENUMERATION OF

(made,

bought,

not_known);

END_TYPE; -- source

TYPE specified_item = SELECT

(product_definition,

shape_aspect);

END_TYPE; -- specified_item

TYPE start_request_item = SELECT

(product_definition_formation);

END_TYPE; -- start_request_item

TYPE supported_item = SELECT

(action_directive,

action,

action_method);

END_TYPE; -- supported_item

TYPE surface_model = SELECT

(shell_based_surface_model);

END_TYPE; -- surface_model

TYPE text = STRING;

END_TYPE; -- text

TYPE transformation = SELECT

(item_defined_transformation,

functionally_defined_transformation);

END_TYPE; -- transformation

TYPE transition_code = ENUMERATION OF

(discontinuous,

continuous,

cont_same_gradient,

cont_same_gradient_same_curvature);

END_TYPE; -- transition_code

TYPE trimming_preference = ENUMERATION OF

(cartesian,

parameter,

unspecified);

END_TYPE; -- trimming_preference

TYPE trimming_select = SELECT

(cartesian_point,

parameter_value);

END_TYPE; -- trimming_select

TYPE unit = SELECT

(named_unit);

END_TYPE; -- unit

TYPE vector_or_direction = SELECT

(vector,

direction);

END_TYPE; -- vector_or_direction

TYPE volume_measure = REAL;

END_TYPE; -- volume_measure

TYPE week_in_year_number = INTEGER;

WHERE

wr1: ((1 <= SELF) AND (SELF <= 53));

END_TYPE; -- week_in_year_number

TYPE wireframe_model = SELECT

(shell_based_wireframe_model,

edge_based_wireframe_model);

END_TYPE; -- wireframe_model

TYPE work_item = SELECT

(product_definition_formation);

END_TYPE; -- work_item

TYPE year_number = INTEGER;

END_TYPE; -- year_number

ENTITY action;

name : label;

description : text;

chosen_method : action_method;

END_ENTITY; -- action

ENTITY action_assignment

ABSTRACT SUPERTYPE;

assigned_action : action;

END_ENTITY; -- action_assignment

ENTITY action_directive;

name : label;

description : text;

analysis : text;

comment : text;

requests : SET [1:?] OF versioned_action_request;

END_ENTITY; -- action_directive

ENTITY action_method;

name : label;

description : text;

consequence : text;

purpose : text;

END_ENTITY; -- action_method

ENTITY action_request_assignment

ABSTRACT SUPERTYPE;

assigned_action_request : versioned_action_request;

END_ENTITY; -- action_request_assignment

ENTITY action_request_solution;

method : action_method;

request : versioned_action_request;

END_ENTITY; -- action_request_solution

ENTITY action_request_status;

status : label;

assigned_request : versioned_action_request;

END_ENTITY; -- action_request_status

ENTITY action_status;

status : label;

assigned_action : executed_action;

END_ENTITY; -- action_status

ENTITY address;

internal_location : OPTIONAL label;

street_number : OPTIONAL label;

street : OPTIONAL label;

postal_box : OPTIONAL label;

town : OPTIONAL label;

region : OPTIONAL label;

postal_code : OPTIONAL label;

country : OPTIONAL label;

facsimile_number : OPTIONAL label;

telephone_number : OPTIONAL label;

electronic_mail_address : OPTIONAL label;

telex_number : OPTIONAL label;

WHERE

wr1: (EXISTS(internal_location) OR EXISTS(street_number) OR EXISTS(

street) OR EXISTS(postal_box) OR EXISTS(town) OR EXISTS(

region) OR EXISTS(postal_code) OR EXISTS(country) OR EXISTS(

facsimile_number) OR EXISTS(telephone_number) OR EXISTS(

electronic_mail_address) OR EXISTS(telex_number));

END_ENTITY; -- address

ENTITY advanced_brep_shape_representation

SUBTYPE OF (shape_representation);

WHERE

wr1: (SIZEOF(QUERY ( it <* SELF.items | (NOT (SIZEOF([

'CONFIG_CONTROL_DESIGN.MANIFOLD_SOLID_BREP',

'CONFIG_CONTROL_DESIGN.FACETED_BREP',

'CONFIG_CONTROL_DESIGN.MAPPED_ITEM',

'CONFIG_CONTROL_DESIGN.AXIS2_PLACEMENT_3D'] * TYPEOF(it)) =

1)) )) = 0);

wr2: (SIZEOF(QUERY ( it <* SELF.items | (SIZEOF([

'CONFIG_CONTROL_DESIGN.MANIFOLD_SOLID_BREP',

'CONFIG_CONTROL_DESIGN.MAPPED_ITEM'] * TYPEOF(it)) = 1) )) >

0);

wr3: (SIZEOF(QUERY ( msb <* QUERY ( it <* SELF.items | (

'CONFIG_CONTROL_DESIGN.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) )

| (NOT (SIZEOF(QUERY ( csh <* msb_shells(msb) | (NOT (

SIZEOF(QUERY ( fcs <* csh\connected_face_set.cfs_faces | (

NOT ('CONFIG_CONTROL_DESIGN.ADVANCED_FACE'

IN TYPEOF(fcs))) )) = 0)) )) = 0)) )) = 0);

wr4: (SIZEOF(QUERY ( msb <* QUERY ( it <* items | (

'CONFIG_CONTROL_DESIGN.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) )

| ('CONFIG_CONTROL_DESIGN.ORIENTED_CLOSED_SHELL' IN TYPEOF(

msb\manifold_solid_brep.outer)) )) = 0);

wr5: (SIZEOF(QUERY ( brv <* QUERY ( it <* items | (

'CONFIG_CONTROL_DESIGN.BREP_WITH_VOIDS' IN TYPEOF(it)) ) | (

NOT (SIZEOF(QUERY ( csh <* brv\brep_with_voids.voids | csh\

oriented_closed_shell.orientation )) = 0)) )) = 0);

wr6: (SIZEOF(QUERY ( mi <* QUERY ( it <* items | (

'CONFIG_CONTROL_DESIGN.MAPPED_ITEM' IN TYPEOF(it)) ) | (NOT

('CONFIG_CONTROL_DESIGN.ADVANCED_BREP_SHAPE_REPRESENTATION'

IN TYPEOF(mi\mapped_item.mapping_source.

mapped_representation))) )) = 0);

END_ENTITY; -- advanced_brep_shape_representation

ENTITY advanced_face

SUBTYPE OF (face_surface);

WHERE

wr1 : (SIZEOF(['CONFIG_CONTROL_DESIGN.ELEMENTARY_SURFACE',

'CONFIG_CONTROL_DESIGN.B_SPLINE_SURFACE',

'CONFIG_CONTROL_DESIGN.SWEPT_SURFACE'] * TYPEOF(

face_geometry)) = 1);

wr2 : (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.EDGE_LOOP' IN TYPEOF(bnds.bound)) )

| (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path.

edge_list | (NOT ('CONFIG_CONTROL_DESIGN.EDGE_CURVE' IN

TYPEOF(oe\oriented_edge.edge_element))) )) = 0)) )) = 0);

wr3 : (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.EDGE_LOOP' IN TYPEOF(bnds.bound)) )

| (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path.

edge_list | (NOT (SIZEOF(['CONFIG_CONTROL_DESIGN.LINE',

'CONFIG_CONTROL_DESIGN.CONIC',

'CONFIG_CONTROL_DESIGN.POLYLINE',

'CONFIG_CONTROL_DESIGN.SURFACE_CURVE',

'CONFIG_CONTROL_DESIGN.B_SPLINE_CURVE'] * TYPEOF(oe.

edge_element\edge_curve.edge_geometry)) = 1)) )) = 0)) )) =

0);

wr4 : (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.EDGE_LOOP' IN TYPEOF(bnds.bound)) )

| (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path.

edge_list | (NOT (('CONFIG_CONTROL_DESIGN.VERTEX_POINT' IN

TYPEOF(oe\edge.edge_start)) AND (

'CONFIG_CONTROL_DESIGN.CARTESIAN_POINT' IN TYPEOF(oe\edge.

edge_start\vertex_point.vertex_geometry)) AND (

'CONFIG_CONTROL_DESIGN.VERTEX_POINT' IN TYPEOF(oe\edge.

edge_end)) AND ('CONFIG_CONTROL_DESIGN.CARTESIAN_POINT' IN

TYPEOF(oe\edge.edge_end\vertex_point.vertex_geometry)))) ))

= 0)) )) = 0);

wr5 : (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.EDGE_LOOP' IN TYPEOF(bnds.bound)) )

| ('CONFIG_CONTROL_DESIGN.ORIENTED_PATH' IN TYPEOF(

elp_fbnds.bound)) )) = 0);

wr6 : ((NOT ('CONFIG_CONTROL_DESIGN.SWEPT_SURFACE' IN TYPEOF(

face_geometry))) OR (SIZEOF(['CONFIG_CONTROL_DESIGN.LINE',

'CONFIG_CONTROL_DESIGN.CONIC',

'CONFIG_CONTROL_DESIGN.POLYLINE',

'CONFIG_CONTROL_DESIGN.B_SPLINE_CURVE'] * TYPEOF(

face_geometry\swept_surface.swept_curve)) = 1));

wr7 : (SIZEOF(QUERY ( vlp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.VERTEX_LOOP'

IN TYPEOF(bnds.bound)) )

| (NOT (('CONFIG_CONTROL_DESIGN.VERTEX_POINT' IN TYPEOF(

vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND (

'CONFIG_CONTROL_DESIGN.CARTESIAN_POINT' IN TYPEOF(vlp_fbnds

\face_bound.bound\vertex_loop.loop_vertex\vertex_point.

vertex_geometry)))) )) = 0);

wr8 : (SIZEOF(QUERY ( bnd <* bounds | (NOT (SIZEOF([

'CONFIG_CONTROL_DESIGN.EDGE_LOOP',

'CONFIG_CONTROL_DESIGN.VERTEX_LOOP'] * TYPEOF(bnd.bound)) =

1)) )) = 0);

wr9 : (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'CONFIG_CONTROL_DESIGN.EDGE_LOOP' IN TYPEOF(bnds.bound)) )

| (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path.

edge_list | (('CONFIG_CONTROL_DESIGN.SURFACE_CURVE' IN

TYPEOF(oe\oriented_edge.edge_element\edge_curve.

edge_geometry)) AND (NOT (SIZEOF(QUERY ( sc_ag <* oe.

edge_element\edge_curve.edge_geometry\surface_curve.

associated_geometry | (NOT ('CONFIG_CONTROL_DESIGN.PCURVE'

IN TYPEOF(sc_ag))) )) = 0))) )) = 0)) )) = 0);

wr10: (((NOT ('CONFIG_CONTROL_DESIGN.SWEPT_SURFACE' IN TYPEOF(

face_geometry))) OR (NOT ('CONFIG_CONTROL_DESIGN.POLYLINE'

IN TYPEOF(face_geometry\swept_surface.swept_curve))) OR (

SIZEOF(face_geometry\swept_surface.swept_curve\polyline.

points) >= 3)) AND (SIZEOF(QUERY ( elp_fbnds <*

QUERY ( bnds <* bounds | ('CONFIG_CONTROL_DESIGN.EDGE_LOOP'

IN TYPEOF(bnds.bound)) ) | (NOT (SIZEOF(QUERY ( oe <*

elp_fbnds.bound\path.edge_list | ((

'CONFIG_CONTROL_DESIGN.POLYLINE' IN TYPEOF(oe\oriented_edge

.edge_element\edge_curve.edge_geometry)) AND (NOT (SIZEOF(

oe\oriented_edge.edge_element\edge_curve.edge_geometry\

polyline.points) >= 3))) )) = 0)) )) = 0));

END_ENTITY; -- advanced_face

ENTITY alternate_product_relationship;

name : label;

definition : text;

alternate : product;

base : product;

basis : text;

UNIQUE

ur1 : alternate, base;

WHERE

wr1: (alternate :<>: base);

END_ENTITY; -- alternate_product_relationship

ENTITY application_context;

application : text;

INVERSE

context_elements : SET [1:?] OF application_context_element FOR

frame_of_reference;

END_ENTITY; -- application_context

ENTITY application_context_element

SUPERTYPE OF (ONEOF (product_context,product_definition_context,

product_concept_context));

name : label;

frame_of_reference : application_context;

END_ENTITY; -- application_context_element

ENTITY application_protocol_definition;

status : label;

application_interpreted_model_schema_name : label;

application_protocol_year : year_number;

application : application_context;

END_ENTITY; -- application_protocol_definition

ENTITY approval;

status : approval_status;

level : label;

END_ENTITY; -- approval

ENTITY approval_assignment

ABSTRACT SUPERTYPE;

assigned_approval : approval;

END_ENTITY; -- approval_assignment

ENTITY approval_date_time;

date_time : date_time_select;

dated_approval : approval;

END_ENTITY; -- approval_date_time

ENTITY approval_person_organization;

person_organization : person_organization_select;

authorized_approval : approval;

role : approval_role;

END_ENTITY; -- approval_person_organization

ENTITY approval_relationship;

name : label;

description : text;

relating_approval : approval;

related_approval : approval;

END_ENTITY; -- approval_relationship

ENTITY approval_role;

role : label;

END_ENTITY; -- approval_role

ENTITY approval_status;

name : label;

END_ENTITY; -- approval_status

ENTITY area_measure_with_unit

SUBTYPE OF (measure_with_unit);

WHERE

wr1: ('CONFIG_CONTROL_DESIGN.AREA_UNIT' IN TYPEOF(SELF\

measure_with_unit.unit_component));

END_ENTITY; -- area_measure_with_unit

ENTITY area_unit

SUBTYPE OF (named_unit);

WHERE

wr1: ((SELF\named_unit.dimensions.length_exponent = 2) AND (SELF\

named_unit.dimensions.mass_exponent = 0) AND (SELF\

named_unit.dimensions.time_exponent = 0) AND (SELF\

named_unit.dimensions.electric_current_exponent = 0) AND (

SELF\named_unit.dimensions.

thermodynamic_temperature_exponent = 0) AND (SELF\named_unit

.dimensions.amount_of_substance_exponent = 0) AND (SELF\

named_unit.dimensions.luminous_intensity_exponent = 0));

END_ENTITY; -- area_unit

ENTITY assembly_component_usage

SUPERTYPE OF (ONEOF (next_assembly_usage_occurrence,

specified_higher_usage_occurrence,promissory_usage_occurrence))

SUBTYPE OF (product_definition_usage);

reference_designator : OPTIONAL identifier;

END_ENTITY; -- assembly_component_usage

ENTITY assembly_component_usage_substitute;

name : label;

definition : text;

base : assembly_component_usage;

substitute : assembly_component_usage;

UNIQUE

ur1 : base, substitute;

WHERE

wr1: (base.relating_product_definition :=: substitute.

relating_product_definition);

wr2: (base :<>: substitute);

END_ENTITY; -- assembly_component_usage_substitute

ENTITY axis1_placement

SUBTYPE OF (placement);

axis : OPTIONAL direction;

DERIVE

z : direction := NVL(normalise(axis),dummy_gri ||

direction([0,0,1]));

WHERE

wr1: (SELF\geometric_representation_item.dim = 3);

END_ENTITY; -- axis1_placement

ENTITY axis2_placement_2d

SUBTYPE OF (placement);

ref_direction : OPTIONAL direction;

DERIVE

p : LIST [2:2] OF direction := build_2axes(ref_direction);

WHERE

wr1: (SELF\geometric_representation_item.dim = 2);

END_ENTITY; -- axis2_placement_2d

ENTITY axis2_placement_3d

SUBTYPE OF (placement);

axis : OPTIONAL direction;

ref_direction : OPTIONAL direction;

DERIVE

p : LIST [3:3] OF direction := build_axes(axis,ref_direction);

WHERE

wr1: (SELF\placement.location.dim = 3);

wr2: ((NOT EXISTS(axis)) OR (axis.dim = 3));

wr3: ((NOT EXISTS(ref_direction)) OR (ref_direction.dim = 3));

wr4: ((NOT EXISTS(axis)) OR (NOT EXISTS(ref_direction)) OR (

cross_product(axis,ref_direction).magnitude > 0));

END_ENTITY; -- axis2_placement_3d

ENTITY b_spline_curve

SUPERTYPE OF (ONEOF (uniform_curve,b_spline_curve_with_knots,

quasi_uniform_curve,bezier_curve) ANDOR rational_b_spline_curve)

SUBTYPE OF (bounded_curve);

degree : INTEGER;

control_points_list : LIST [2:?] OF cartesian_point;

curve_form : b_spline_curve_form;

closed_curve : LOGICAL;

self_intersect : LOGICAL;

DERIVE

upper_index_on_control_points : INTEGER := SIZEOF(

control_points_list) - 1;

control_points : ARRAY [0:

upper_index_on_control_points] OF

cartesian_point := list_to_array(

control_points_list,0,

upper_index_on_control_points);

WHERE

wr1: (('CONFIG_CONTROL_DESIGN.UNIFORM_CURVE' IN TYPEOF(SELF)) OR (

'CONFIG_CONTROL_DESIGN.QUASI_UNIFORM_CURVE' IN TYPEOF(SELF))

OR ('CONFIG_CONTROL_DESIGN.BEZIER_CURVE' IN TYPEOF(SELF)) OR

('CONFIG_CONTROL_DESIGN.B_SPLINE_CURVE_WITH_KNOTS' IN

TYPEOF(SELF)));

END_ENTITY; -- b_spline_curve

ENTITY b_spline_curve_with_knots

SUBTYPE OF (b_spline_curve);

knot_multiplicities : LIST [2:?] OF INTEGER;

knots : LIST [2:?] OF parameter_value;

knot_spec : knot_type;

DERIVE

upper_index_on_knots : INTEGER := SIZEOF(knots);

WHERE

wr1: constraints_param_b_spline(degree,upper_index_on_knots,

upper_index_on_control_points,knot_multiplicities,knots);

wr2: (SIZEOF(knot_multiplicities) = upper_index_on_knots);

END_ENTITY; -- b_spline_curve_with_knots

ENTITY b_spline_surface

SUPERTYPE OF (ONEOF (b_spline_surface_with_knots,uniform_surface,

quasi_uniform_surface,bezier_surface) ANDOR

rational_b_spline_surface)

SUBTYPE OF (bounded_surface);

u_degree : INTEGER;

v_degree : INTEGER;

control_points_list : LIST [2:?] OF LIST [2:?] OF cartesian_point;

surface_form : b_spline_surface_form;

u_closed : LOGICAL;

v_closed : LOGICAL;

self_intersect : LOGICAL;

DERIVE

u_upper : INTEGER := SIZEOF(control_points_list) - 1;

v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;

control_points : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF

cartesian_point := make_array_of_array(

control_points_list,0,u_upper,0,v_upper);

WHERE

wr1: (('CONFIG_CONTROL_DESIGN.UNIFORM_SURFACE' IN TYPEOF(SELF)) OR (

'CONFIG_CONTROL_DESIGN.QUASI_UNIFORM_SURFACE' IN

TYPEOF(SELF))

OR ('CONFIG_CONTROL_DESIGN.BEZIER_SURFACE' IN TYPEOF(SELF))

OR ('CONFIG_CONTROL_DESIGN.B_SPLINE_SURFACE_WITH_KNOTS' IN

TYPEOF(SELF)));

END_ENTITY; -- b_spline_surface

ENTITY b_spline_surface_with_knots

SUBTYPE OF (b_spline_surface);

u_multiplicities : LIST [2:?] OF INTEGER;

v_multiplicities : LIST [2:?] OF INTEGER;

u_knots : LIST [2:?] OF parameter_value;

v_knots : LIST [2:?] OF parameter_value;

knot_spec : knot_type;

DERIVE

knot_u_upper : INTEGER := SIZEOF(u_knots);

knot_v_upper : INTEGER := SIZEOF(v_knots);

WHERE

wr1: constraints_param_b_spline(SELF\b_spline_surface.u_degree,

knot_u_upper,SELF\b_spline_surface.u_upper,u_multiplicities,

u_knots);

wr2: constraints_param_b_spline(SELF\b_spline_surface.v_degree,

knot_v_upper,SELF\b_spline_surface.v_upper,v_multiplicities,

v_knots);

wr3: (SIZEOF(u_multiplicities) = knot_u_upper);

wr4: (SIZEOF(v_multiplicities) = knot_v_upper);

END_ENTITY; -- b_spline_surface_with_knots

ENTITY bezier_curve

SUBTYPE OF (b_spline_curve);

END_ENTITY; -- bezier_curve

ENTITY bezier_surface

SUBTYPE OF (b_spline_surface);

END_ENTITY; -- bezier_surface

ENTITY boundary_curve

SUBTYPE OF (composite_curve_on_surface);

WHERE

wr1: SELF\composite_curve.closed_curve;

END_ENTITY; -- boundary_curve

ENTITY bounded_curve

SUPERTYPE OF (ONEOF (polyline,b_spline_curve,trimmed_curve,

bounded_pcurve,bounded_surface_curve,composite_curve))

SUBTYPE OF (curve);

END_ENTITY; -- bounded_curve

ENTITY bounded_pcurve

SUBTYPE OF (pcurve, bounded_curve);

WHERE

wr1: ('CONFIG_CONTROL_DESIGN.BOUNDED_CURVE' IN TYPEOF(SELF\pcurve.

reference_to_curve.items[1]));

END_ENTITY; -- bounded_pcurve

ENTITY bounded_surface

SUPERTYPE OF (ONEOF (b_spline_surface,rectangular_trimmed_surface,

curve_bounded_surface,rectangular_composite_surface))

SUBTYPE OF (surface);

END_ENTITY; -- bounded_surface

ENTITY bounded_surface_curve

SUBTYPE OF (surface_curve, bounded_curve);

WHERE

wr1: ('CONFIG_CONTROL_DESIGN.BOUNDED_CURVE' IN TYPEOF(SELF\

surface_curve.curve_3d));

END_ENTITY; -- bounded_surface_curve

ENTITY brep_with_voids

SUBTYPE OF (manifold_solid_brep);

voids : SET [1:?] OF oriented_closed_shell;

END_ENTITY; -- brep_with_voids

ENTITY calendar_date

SUBTYPE OF (date);

day_component : day_in_month_number;

month_component : month_in_year_number;

WHERE

wr1: valid_calendar_date(SELF);

END_ENTITY; -- calendar_date

ENTITY cartesian_point

SUBTYPE OF (point);

coordinates : LIST [1:3] OF length_measure;

END_ENTITY; -- cartesian_point

ENTITY cartesian_transformation_operator

SUPERTYPE OF (cartesian_transformation_operator_3d)

SUBTYPE OF (geometric_representation_item,

functionally_defined_transformation);

axis1 : OPTIONAL direction;

axis2 : OPTIONAL direction;

local_origin : cartesian_point;

scale : OPTIONAL REAL;

DERIVE

scl : REAL := NVL(scale,1);

WHERE

wr1: (scl > 0);

END_ENTITY; -- cartesian_transformation_operator

ENTITY cartesian_transformation_operator_3d

SUBTYPE OF (cartesian_transformation_operator);

axis3 : OPTIONAL direction;

DERIVE

u : LIST [3:3] OF direction := base_axis(3,SELF\

cartesian_transformation_operator.axis1,SELF\

cartesian_transformation_operator.axis2,axis3);

WHERE

wr1: (SELF\geometric_representation_item.dim = 3);

END_ENTITY; -- cartesian_transformation_operator_3d

ENTITY cc_design_approval

SUBTYPE OF (approval_assignment);

items : SET [1:?] OF approved_item;

END_ENTITY; -- cc_design_approval

ENTITY cc_design_certification

SUBTYPE OF (certification_assignment);

items : SET [1:?] OF certified_item;

END_ENTITY; -- cc_design_certification

ENTITY cc_design_contract

SUBTYPE OF (contract_assignment);

items : SET [1:?] OF contracted_item;

END_ENTITY; -- cc_design_contract

ENTITY cc_design_date_and_time_assignment

SUBTYPE OF (date_and_time_assignment);

items : SET [1:?] OF date_time_item;

WHERE

wr1: cc_design_date_time_correlation(SELF);

END_ENTITY; -- cc_design_date_and_time_assignment

ENTITY cc_design_person_and_organization_assignment

SUBTYPE OF (person_and_organization_assignment);

items : SET [1:?] OF person_organization_item;

WHERE

wr1: cc_design_person_and_organization_correlation(SELF);

END_ENTITY; -- cc_design_person_and_organization_assignment

ENTITY cc_design_security_classification

SUBTYPE OF (security_classification_assignment);

items : SET [1:?] OF classified_item;

END_ENTITY; -- cc_design_security_classification

ENTITY cc_design_specification_reference

SUBTYPE OF (document_reference);

items : SET [1:?] OF specified_item;

END_ENTITY; -- cc_design_specification_reference

ENTITY certification;

name : label;

purpose : text;

kind : certification_type;

END_ENTITY; -- certification

ENTITY certification_assignment

ABSTRACT SUPERTYPE;

assigned_certification : certification;

END_ENTITY; -- certification_assignment

ENTITY certification_type;

description : label;

END_ENTITY; -- certification_type

ENTITY change

SUBTYPE OF (action_assignment);

items : SET [1:?] OF work_item;

END_ENTITY; -- change

ENTITY change_request

SUBTYPE OF (action_request_assignment);

items : SET [1:?] OF change_request_item;

END_ENTITY; -- change_request

ENTITY circle

SUBTYPE OF (conic);

radius : positive_length_measure;

END_ENTITY; -- circle

ENTITY closed_shell

SUBTYPE OF (connected_face_set);

END_ENTITY; -- closed_shell

ENTITY composite_curve

SUBTYPE OF (bounded_curve);

segments : LIST [1:?] OF composite_curve_segment;

self_intersect : LOGICAL;

DERIVE