SCHEMA_MAP AIM2PLM_Equicalence;

REFERENCE FROM AUTOMOTIVE_DESIGN AS SOURCE;
REFERENCE FROM ARM_SCHEMA_214 AS TARGET;

MAP item_map AS
  it : item;
FROM
  p    : product;
  prpc : product_related_product_category;  
WHERE
  wr1: p IN prpc.products;
  wr2: prpc.name IN ['part', 'raw material', 'tool'];
IDENTIFIED_BY p;
SELECT
  it.id          := p.id;
  it.name        := p.name;
  it.description := p.description;
END_MAP;  

MAP item_version_map AS 
  iv : item_version;
FROM
  pdf : product_definition_formation;
WHERE
  EXISTS(item_map(pdf.of_product));
SELECT
  iv.id := pdf.id;
  iv.associated_item := item_map(pdf.of_product);
  iv.description := pdf.description;
END_MAP;

MAP item_version_relationship_map AS
  ivr : item_version_relationship;
FROM
  pdfr : product_definition_formation_relationship;  
WHERE
  EXISTS(item_version_map(pdfr.related_product_definition_formation)) AND 
  EXISTS(item_version_map(pdfr.relating_product_definition_formation));
SELECT
  ivr.description   := pdfr.description;
  ivr.relation_type := pdfr.name;
  ivr.related       :=
          item_version_map(pdfr.related_product_definition_formation);
  ivr.relating      :=
          item_version_map(pdfr.relating_product_definition_formation);
END_MAP;

MAP application_context_map AS
  actx : application_context;
FROM
  pdctx : product_definition_context;
SELECT
  actx.life_cycle_stage   := pdctx.life_cycle_stage;
  actx.application_domain := pdctx.frame_of_reference.application;
END_MAP;

MAP ddid_map AS
  ddid : design_discipline_item_definition;
FROM
  pd : product_definition;
WHERE
  wr1: pd.frame_of_reference.name = 'part definition';
SELECT
  ddid.id                      := pd.id;
  ddid.name                    := pd.name;
  ddid.associated_item_version := item_version_map(pd.formation);
  ddid.initial_context := application_context_map(pd.frame_of_reference);
  ddid.additional_context := 
    FOR EACH pdca IN pd<-
      pd<-definition{product_definition_context_association |
                     role.name = 'additional context'};
      RETURN application_context_map(pdca.frame_of_reference);
END_MAP;

MAP assembly_definition_map AS
  ddid : assembly_definition;
SUBTYPE OF (ddid_map);
WHERE
  SIZEOF(pd<-definition{product_definition_context_association |
                         role.name = 'part definition type'}
            ::frame_of_reference{product_definition_context | 
                                 name = 'assembly definition'}) > 0;
END_MAP;

MAP collection_definition_map AS
  ddid : collection_definition;
SUBTYPE OF (ddid_map);
WHERE
  (SIZEOF(pd<-definition{product_definition_context_association |
                         role.name = 'part definition type'}
            ::frame_of_reference{product_definition_context | 
                                 name = 'collection definition'}) > 0);
END_MAP;

MAP process_state_map AS
  ddid : process_state;
SUBTYPE OF (ddid_map);
WHERE
  SIZEOF(pd<-definition{product_definition_context_association |
                        role.name = 'part definition type'} 
           ::frame_of_reference{product_definition_context | 
                                name= 'process state'}) > 0;
SELECT
  ddid.related_item_definition := 
    ddid_map(pd<-related_product_definition
                 {product_definition_relationship | 
                  name = 'process state to related item'}
               ::relating_product_definition[1]);
END_MAP;

MAP item_definition_instance_relationship_map AS
  rel : item_definition_instance_relationship;
FROM
  pdr : product_definition_relationship;
WHERE
  wr1: pdr.relating_product_definition.frame_of_reference.name = 
       'part definition';
  wr2: (pdr.related_product_definition.frame_of_reference.name = 
       'part occurrence') OR 
       ('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN TYPEOF(rel)) AND
       (pdr.related_product_definition.frame_of_reference.name = 
       'part definition');
SELECT
  rel.relating := ddid_map(pdr.relating_product_definition);
  rel.related  := IF 'AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_RELATIONSHIP'
                     IN TYPEOF(rel)
                  THEN
                    item_instance_map(
                      pdr.related_product_definition
                         <-related_product_definition
                           {product_definition_relationship | 
                            name = 'definition usage'}::
                            relating_product_definition{product_definition|
                              pdr IN product_definition<-occurence
                              {product_definition_occurrence_relationship}
                              ::occurrence_usage}[1]);
                  ELSE
                    item_instance_map(pdr.related_product_definition);
                  END_IF;
END_MAP;

MAP assembly_structure_map AS
  rel : assembly_component_relationship;
SUBTYPE OF (item_definition_instance_relationship_map);
WHERE
  'AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_RELATIONSHIP' IN TYPEOF(pdr);
SELECT
  acr.placement   := 
    model_relationship_map(pdr<-definition{product_definition_shape}
                              <-represented_product_relation
                                {context_dependent_shape_representation}
                              ::representation_relation[1]);
END_MAP;

MAP next_higher_assembly_map AS
  rel : next_higher_assembly;
SUBTYPE OF (assembly_structure_map);
WHERE
  'AUTOMOTIVE_DESIGN.NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN TYPEOF(pdr);
END_MAP;

MAP collected_item_association_map AS
  rel : collected_item_association;
SUBTYPE OF (item_definition_instance_relationship);
WHERE
  pdr.name = 'collection membership';
END_MAP;

MAP general_item_definition_instance_relationship_map AS
  rel : general_item_definition_instance_relationship;
SUBTYPE OF (item_definition_instance_relationship);
WHERE
  OTHERWISE;
SELECT
  rel.description := pdr.description;
  rel.relation_type := pdr.name;
END_MAP;

MAP item_definition_relationship_map AS
  idr : item_definition_relationship;
FROM
  pdrel : product_definition_relationship;
WHERE
  wr1: pdrel.relating_product_definition.frame_of_reference.name 
       = 'part definition';
  wr2: pdrel.related_product_definition.frame_of_reference.name 
       = 'part definition';
  wr3: NOT ('AUTOMOTIVE_DESIGN.ASSEMBLY_COMPONENT_USAGE' IN TYPEOF(rel));
SELECT
  idr.relating := ddid_map(pdrel.relating_product_definition);
  idr.related  := ddid_map(pdrel.related_product_definition);
END_MAP;

MAP make_from_relationship_map AS
  idr : make_from_relationship;
SUBTYPE OF (item_definition_relationship_map);
WHERE
  wr3: 'AUTOMOTIVE_DESIGN.MAKE_FROM_USAGE_OPTION' IN TYPEOF(pdrel);
SELECT  
  idr.description := pdrel.description;
END_MAP;

MAP replaced_definition_relationship_map AS
  idr : replaced_definition_relationship;
SUBTYPE OF (item_definition_relationship_map);
WHERE
  wr3: pdrel.name = 'definition replacement';
SELECT  
  idr.description := pdrel.description;
END_MAP;

MAP geometrical_relationship_map AS
  idr : geometrical_relationship;
SUBTYPE OF (item_definition_relationship_map);
WHERE
  wr3: pdrel.name = 'geometrical relationship';
SELECT  
  idr.description := pdrel.description;
  idr.definition_placement := 
   model_relationship_trafo_map(pdrel<-definition{product_definition_shape}
                                 <-represented_product_relation
                                   {context_dependent_shape_representation}
                              ::representation_relation[1]);
END_MAP;

MAP tool_part_relationship_map AS
  idr : tool_part_relationship;
WHERE
  wr3: pdrel.name = 'tool part relationship';
SELECT
  idr.used_technology_description := pdrel.description;
  idr.placement := 
   model_relationship_trafo_map(pdrel<-definition{product_definition_shape}
                                 <-represented_product_relation
                                   {context_dependent_shape_representation}
                              ::representation_relation[1]);
END_MAP;

MAP general_item_definition_relationship_map AS
  idr : general_item_definition_relationship;
SUBTYPE OF (item_definition_relationship_map);
WHERE
  OTHERWISE;
SELECT  
  idr.description := pdrel.description;
  idr.relation_type := pdrel.name;
END_MAP;

MAP item_instance_map AS
  ii : item_instance;
FROM
  pd : product_definition;
WHERE
  pd.frame_of_reference.name = 'part occurrence';
SELECT
  ii.description := pd.description;
  ii.id := pd.id;
  ii.definition := IF SIZEOF(pd<-related_product_definition
                                 {product_definition_relationship | 
                                  name = 'definition usage'}) > 0
                 THEN
                     ddid_map(pd<-related_product_definition
                                  {product_definition_relationship | 
                                   name = 'definition usage'}
                                ::relating_product_definition[1]);
                  ELSE
                    product_identification_map(
                      pd<-design{configuration_design |
                                 name = 'occurrence usage definition'}
                        ::configuration{product_identification}[1]);
                  END_IF;
END_MAP;

MAP single_instance_map AS
  ii : single_instance;
SUBTYPE OF (item_instance);
WHERE
  pd.name = 'single instance';
END_MAP;

MAP quantified_instance_map AS
  ii : quantified_instance;
SUBTYPE OF (item_instance);
WHERE
  pd.name = 'quantified instance';
SELECT
  ii.quantity := numerical_value_map(
                 pd<-definition{property_definition |
                                name = 'occurrence quantity'}
                   <-definition{property_definition_representation}
                   ::used_representation{representation | name='quantity'}
                   ::items{measure_representation_item | 
                           name = 'quantity measure'}[1]);
END_MAP;

MAP selected_instance_map AS
  ii : selected_instance;
SUBTYPE OF (item_instance);
WHERE
  pd.name = 'selected instance';
SELECT
  ii.selection_control := 
    pd<-definition{property_definition | name = 'occurrence selection'}
      <-definition{property_definition_representation}
      ::used_representation{representation | name = 'selection criteria'}
      ::items{descriptive_representation_item | 
              name = 'selection control' }[1].description;
  ii.selected_quantity := value_with_unit_map(
    pd<-definition{property_definition | name = 'occurrence selection'}
      <-definition{property_definition_representation}
      ::used_representation{representation | name = 'selection criteria'}
      ::items{representation_item | name = 'selection quantity'}[1]);
END_MAP;

MAP specified_instance_map AS
  ii : specified_instance;
SUBTYPE OF (item_instance);
WHERE
  pd.name = 'specified instance';
SELECT
  ii.assembly_context := assembly_definition_map(
    pd<-occurrence{product_definition_occurrence_relationship}
      ::occurrence_usage{specified_higher_usage_occurrence}
      ::relating_product_definition[1]);
  ii.related_instance := item_instance_map(
   pd<-occurrence{product_definition_occurrence_relationship}
      ::occurrence_usage{specified_higher_usage_occurrence}
      ::next_usage{next_assembly_usage_occurrence}
      <-occurrence_usage{product_definition_occurrence_relationship}
      ::occurrence{product_definition}[1]);
  ii.upper_usage := item_instance_map(
   pd<-occurrence{product_definition_occurrence_relationship}
      ::upper_usage{next_assembly_usage_occurrence}
      ::occurrence_usage{specified_higher_usage_occurrence}
      <-occurrence_usage{product_definition_occurrence_relationship}
     ::occurrence{product_definition}[1]);
END_MAP;

MAP item_instance_relationship_map AS
  iir : item_instance_relationship ;
PARTITION p_pdr ;
FROM
  pdr : product_definition_relationship ;
WHERE
  wr1 : pdr.relating_product_definition.frame_of_reference.name =
        'part occurrence' ;
  wr2 : pdr.related_product_definition.frame_of_reference.name =
        'part occurrence' ;
RETURN (item_instance_relationship_pdrel_map(pdr));
PARTITION p_psubst ;
FROM
  ps : product_definition_substitute;
WHERE
  ps.substitute_definition.frame_of_reference.name = 'part occurrence';
RETURN (replaced_usage_relationship_subst_map(ps));
END_MAP ;
DEPENDENT_MAP item_instance_relationship_pdrel_map AS
  iir : item_instance_relationship ;
FROM
  pdr : product_definition_relationship ;
SELECT
  iir.related := item_instance_map(pdr.related_product_definition) ;
END_DEPENDENT_MAP ;

DEPENDENT_MAP general_item_instance_relationship_pdrel_map AS
  iir : general_item_instance_relationship ;
SUBTYPE OF (item_instance_relationship_pdrel_map) ;
WHERE 
  OTHERWISE ;
SELECT
  irr.relating := item_instance_map(pdr.related_product_definition);
  irr.relation_type := pdr.name ;
END_DEPENDENT_MAP ;

DEPENDENT_MAP replaced_usage_relationship_pdrel_map AS
  iir : replaced_usage_relationship ;
SUBTYPE OF (item_instance_relationship_pdrel_map) ; 
WHERE 
  (pdr.name = 'usage replacement') OR
  (pdr.name = 'process input or output replacement');
SELECT
  irr.description   := pdr.description ;
  irr.relating      := item_instance_map(pdr.relating_product_definition);
  irr.usage_context := process_operation_input_or_output_map(
    pdr.relating_product_definition
       <-defined_product{process_product_association}[1]);
  
END_DEPENDENT_MAP ;

DEPENDENT_MAP replaced_usage_relationship_subst_map AS
  rur : replaced_usage_relationship ;
FROM
  ps : product_definition_substitute ;
SELECT
  rur.related := item_instance_map(ps.substitute_definition) ;
  rur.relating := 
        item_instance_map(ps.context_relationship
        <-occurrence_usage{product_definition_occurrence_relationship} 
        ::occurrence[1]) ;
  rur.usage_context := 
    IF 'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_USAGE' IN 
       TYPEOF(ps.context_relationship)
    THEN
      product_structure_relationship(ps.context_relationship) ;
    ELSE
     item_definition_instance_relationship(ps.context_relationship) ;
    END_IF ;
END_DEPENDENT_MAP ;

MAP instance_placement_map AS
  ip : instance_placement;
FROM
  rrel : representation_relation_with_transformation;
WHERE
  rrel.name = 'instance placement';
SELECT
  ip.placed_instance := single_instance_map(
    rrel::rep_1{shape_representation}
        <-used_representation{shape_definition_representation}
        :: represented_definition{product_definition_shape}
        ::definition{product_definition | (name = 'single instance')
                   AND (frame_of_reference.name = 'part occurrence')}[1]);
  ip.placement := geometric_model_relationship(rrel);
  ip.reference_product_component := 
    IF 'AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' IN TYPEOF(rrel.rep_2) THEN
      product_component_map(rrel.rep_2
        <-used_representation{shape_definition_representation}
        :: represented_definition{product_definition_shape}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    ELSE
      product_component_map(rrel::rep_2{representation | 
                                        name = 'model property value'}
        <- used_representation{property_definition_representation}
        :: represented_definition{property_definition | 
                                 name = 'positioning'}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    END_IF;
 END_MAP;

MAP component_placement_map AS
  ip : compnent_placement;
FROM
  rrel : representation_relation_with_transformation;
WHERE
  rrel.name = 'component placement';
SELECT
  ip.placed_component := 
    IF 'AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' IN TYPEOF(rrel.rep_1) THEN
      product_component_map(rrel::rep_1{shape_representation}
        <-used_representation{shape_definition_representation}
        :: represented_definition{product_definition_shape}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    ELSE
      product_component_map(rrel::rep_1{representation | 
                                        name = 'model property value'}
        <- used_representation{property_definition_representation}
        :: represented_definition{property_definition | 
                                 name = 'positioning'}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    END_IF;
  ip.placement := geometric_model_relationship(rrel);
  ip.reference_product_component := 
    IF 'AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' IN TYPEOF(rrel.rep_2) THEN
      product_component_map(rrel.rep_2
        <-used_representation{shape_definition_representation}
        :: represented_definition{product_definition_shape}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    ELSE
      product_component_map(rrel::rep_2{representation | 
                                        name = 'model property value'}
        <- used_representation{property_definition_representation}
        :: represented_definition{property_definition | 
                                 name = 'positioning'}
        ::definition{product_definition | frame_of_reference.name = 
                                          'conceptual definition'}[1]);
    END_IF;
 END_MAP;

MAP document_map AS
  doc : document;
FROM
  p    : product;
  prpc : product_related_product_category;
WHERE
  wr1: p IN prpc.products;
  wr2: prpc.name = 'document';
IDENTIFIED_BY p;
SELECT
  doc.document_id := p.id;
  doc.name        := p.name;
  doc.description := p.description;
END_MAP;  

MAP document_version_map AS 
  dv : document_version;
FROM
  pdf : product_definition_formation;
WHERE
  EXISTS(document_map(pdf.of_product));
SELECT
  dv.id := pdf.id;
  dv.associated_document := document_map(pdf.of_product);
  dv.description := pdf.description;
END_MAP;

MAP document_version_relationship_map AS
  ivr : document_version_relationship;
FROM
  pdfr : product_definition_formation_relationship;
WHERE
  wr1: EXISTS(document_version_map
               (pdfr.related_product_definition_formation));
  wr2: EXISTS(document_version_map
               (pdfr.relating_product_definition_formation));
SELECT
  ivr.description   := pdfr.description;
  ivr.relation_type := pdfr.name;
  ivr.related       := 
    document_version_map(pdfr.related_product_definition_formation);
  ivr.relating      := 
    document_version_map(pdfr.relating_product_definition_formation);
END_MAP;

MAP document_representation_map AS
  drep : document_representation;
FROM
  pd : product_definition;
WHERE
  pd.frame_of_reference.name = 'digital document definition';
SELECT
  drep.id                          := pd.id;
  drep.description                 := pd.description;
  drep.associated_document_version := document_version_map(pd.formation);
  drep.representation_format := 
    document_format_property_map(pd<-definition{property_definition | 
                                           name = 'document property'}
                           <-definition{property_definition_representation}
                           ::used_representation{representation |
                                           name = 'document format'}[1]);
  drep.content := 
    document_content_property_map(pd<-definition{property_definition | 
                                           name = 'document property'}
                          <-definition{property_definition_representation}
                          ::used_representation{representation |
                                           name = 'document content'}[1]);
  drep.creation :=
    document_creation_property_map(pd<-definition{property_definition | 
                                            name = 'document property'}
                          <-definition{property_definition_representation}
                          ::used_representation{representation |
                                           name = 'document creation'}[1]);
  drep.common_location :=
    FOR EACH idx IN pd<-items{applied_external_identification_assignment |
                              role.name = 'common location'}
      RETURN document_location_property_map(idx.SOURCE);  
END_MAP;

MAP digital_document_map AS
  drep : digital_document;
SUBTYPE OF (document_representation_map);
WHERE
  pd.frame_of_reference.name = 'digital document definition';
SELECT
  drep.file := IF 'AUTOMOTIVE_DESIGN.' + 
                 'PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS' IN 
                 TYPEOF(pd)
               THEN
                 FOR EACH df IN pd.documentation_ids
                   RETURN digital_file_map(df);
               ELSE
                 [];
               END_IF;
END_MAP;

MAP physical_document_map AS
  drep : physical_document;
SUBTYPE OF (document_representation_map);
WHERE
  pd.frame_of_reference.name = 'physical document definition';
SELECT
  drep.component := IF 'AUTOMOTIVE_DESIGN.' + 
                      'PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS' IN 
                      TYPEOF(pd)
                    THEN
                      FOR EACH df IN NVL(pd.documentation_ids,[]);
                        RETURN hardcopy_map(df);
                    ELSE
                      [];
                    END_IF;
END_MAP;

MAP document_file_map AS 
  docf : document_file;
FROM
  df  : document_file;
  drt : document_representation_type;
WHERE
  wr1: drt.represented_document :=: df;
  wr2: drt.name IN ['digital', 'physical'];
IDENTIFIED_BY df;
SELECT
  docf.file_id := df.id;
  docf.document_file_type := document_type_property_map(df.kind);
  docf.file_format := 
    document_format_property_map(df<-definition{property_definition | 
                                           name = 'document property'}
                           <-definition{property_definition_representation}
                           ::used_representation{representation |
                                           name = 'document format'}[1]);
  docf.content := 
    document_content_property_map(df<-definition{property_definition | 
                                           name = 'document property'}
                          <-definition{property_definition_representation}
                          ::used_representation{representation |
                                           name = 'document content'}[1]);
  docf.creation :=
    document_creation_property_map(df<-definition{property_definition | 
                                            name = 'document property'}
                          <-definition{property_definition_representation}
                          ::used_representation{representation |
                                           name = 'document creation'}[1]);
  docf.external_id_and_location :=
    FOR EACH idx IN df<-items{applied_external_identification_assignment |
                           role.name = 'external document id and location'}
      RETURN external_file_id_and_location_map(idx);
END_MAP;

MAP digital_file_map AS
  docf : digital_file;
SUBTYPE OF (document_file_map);
WHERE
  drt.name = 'digital';
END_MAP;

MAP hardcopy_map AS
  docf : hardcopy;
SUBTYPE OF (document_file_map);
WHERE
  drt.name = 'physical';
END_MAP;

MAP document_structure_map AS
  dstr : document_structure;
FROM
  pdr : product_definition_relationship;
WHERE
  wr1: EXISTS(document_representation _map(
              pdr.related_product_definition));
  wr2: EXISTS(document_representation_map(
              pdr.relating_product_definition));
SELECT
  dstr.related := 
    document_representation_map(pdr.related_product_definition);
  dstr.relating:=
    document_representation_map(pdr.relating_product_definition);
  dstr.relation_type := pdr.name;
  dstr.description := pdr.description;
END_MAP;

MAP item_document_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  p    : product;
  dpa  : document_product_equivalence;
  dp  : product;
WHERE
  wr1: p IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
'configuration controlled document';
SELECT
  da.assigned_document := document_map(dp);
  da.is_assigned_to    := item_map(p);
  da.role              := adr.role.name;
END_MAP;

MAP item_document_version_assignment_map AS
  da : document_assignment;
FROM
  adr : applied_document_reference;
  p  : product;
  dpa : document_product_equivalence;
  dpdf : product_definition_formation;
WHERE
  wr1: p IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dpdf;
  wr4: adr.assigned_document.kind.product_data_type =
'configuration controlled document version';
SELECT
  da.assigned_document := document_version_map(dpdf);
  da.is_assigned_to    := item_map(p);
  da.role              := adr.role.name;
END_MAP;


MAP item_document_representation_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  p   : product;
  dpa : document_product_equivalence;
  dpd : product_definition;
WHERE
  wr1: p IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dpd;
  wr4: adr.assigned_document.kind.product_data_type = 
          'configuration controlled document representation';
SELECT
  da.assigned_document := document_representation_map(dpd);
  da.is_assigned_to    := item_map(p);
  da.role              := adr.role.name;
END_MAP;

MAP item_digital_file_assignment_map AS
  da : document_assignment;
FROM
  p   : product;
  adr : applied_document_reference;
  df  : document_file;
WHERE
  wr1: p IN adr.items;
  wr2: adr.assigned_document :=: df;
SELECT
  da.assigned_document := digital_file_map(df);
  da.is_assigned_to    := item_map(p);
  da.role              := adr.role.name;
END_MAP;

MAP item_version_document_assignment_map AS
  da : document_assignment;
FROM
  adr : applied_document_reference;
  pdf  : product_definition_formation;
  dpa : document_product_equivalence;
  dp : product;
WHERE
  wr1: pdf IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
'configuration controlled document';
SELECT
  da.assigned_document := document_map(dp);
  da.is_assigned_to    := item_version_map(pdf);
  da.role              := adr.role.name;
END_MAP;

MAP item_version_document_version_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  pdf   : product_definition_formation;
  dpa  : document_product_equivalence;
  dp  : product_definition_formation;
WHERE
  wr1: pdf IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
'configuration controlled document version';
SELECT
  da.assigned_document := document_version_map(dp);
  da.is_assigned_to    := item_version_map(pdf);
  da.role              := adr.role.name;
END_MAP;

MAP item_version_document_representation_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  pdf   : product_definition_formation;
  dpa  : document_product_equivalence;
  dp  : product_definition;
WHERE
  wr1: pdf IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type =
         'configuration controlled document representation';
SELECT
  da.assigned_document := document_representation_map(dp);
  da.is_assigned_to    := item_version_map(pdf);
  da.role              := adr.role.name;
END_MAP;

MAP item_version_digital_file_assignment_map AS
  da : document_assignment;
FROM
  pdf   : product_definition_formation;
  adr : applied_document_reference;
  df  : document_file;
WHERE
  wr1: pdf IN adr.items;
  wr2: adr.assigned_document :=: df;
SELECT
  da.assigned_document := digital_file_map(df);
  da.is_assigned_to    := item_version_map(pdf);
  da.role              := adr.role.name;
END_MAP;

MAP ddid_document_assignment_map AS
  da : document_assignment;
FROM
  adr : applied_document_reference;
  pd: product_definition;
  dpa : document_product_equivalence;
  dp : product;
WHERE
  wr1: pd IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
'configuration controlled document';
SELECT
  da.assigned_document := document_map(dp);
  da.is_assigned_to    := ddid_map(pd);
  da.role              := adr.role.name;
END_MAP;

MAP ddid_document_version_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  pd: product_definition;
  dpa  : document_product_equivalence;
  dp  : product_definition_formation;
WHERE
  wr1: pd IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
'configuration controlled document version';
SELECT
  da.assigned_document := document_version_map(dp);
  da.is_assigned_to    := ddid_map(pd);
  da.role              := adr.role.name;
END_MAP;

MAP ddid_document_representation_assignment_map AS
  da : document_assignment;
FROM
  adr  : applied_document_reference;
  pd   : product_definition;
  dpa  : document_product_equivalence;
  dp   : product_definition;
WHERE
  wr1: pd IN adr.items;
  wr2: dpa.relating_document :=: adr.assigned_document;
  wr3: dpa.related_product   :=: dp;
  wr4: adr.assigned_document.kind.product_data_type = 
         'configuration controlled document representation';
SELECT
  da.assigned_document := document_representation_map(dp);
  da.is_assigned_to    := ddid_map(pd);
  da.role              := adr.role.name;
END_MAP;

MAP ddid_digital_file_assignment_map AS
  da : document_assignment;
FROM
  pd  : product_definition;
  adr : applied_document_reference;
  df  : document_file;
WHERE
  wr1: pd IN adr.items;
  wr2: adr.assigned_document :=: df;
SELECT
  da.assigned_document := digital_file_map(df);
  da.is_assigned_to    := ddid_map(pd);
  da.role              := adr.role.name;
END_MAP;

MAP document_content_property_map AS
  dcp : document_content_property;
FROM
  rep : representation;
WHERE
  wr1: rep.context_of_items.context_type = 'document parameters';
  wr2: rep.name = 'doument content';
SELECT
  dcp.detail_level  := rep::items{descriptive_representation_item | 
                                  name = 'detail level'}[1].description;
  dcp.geometry_type := rep::items{descriptive_representation_item | 
                                  name = 'geometry type'}[1].description;
  dcp.real_world_scale := numerical_value_map(rep::items
   {measure_representation_item | 
                            name = 'real world scale'}[1]);
  dcp.languages := FOR EACH lang IN rep<-items{language_assignment | 
                                               role.name = 'language'}
                                       ::assigned_class{language}
                     RETURN language_map(lang);        
END_MAP;

MAP document_format_property_map AS
  dfp : document_format_property;
FROM
  rep : representation;
WHERE
  wr1: rep.context_of_items.context_type = 'document parameters';
  wr2: rep.name = 'document format';   
SELECT
  dfp.character_code := rep::items{descriptive_representation_item | 
                                   name = 'character code'}[1].description;
  dfp.data_format := rep::items{descriptive_representation_item | 
                                name = 'data format'}[1].description; 
END_MAP;

MAP document_creation_property_map AS
  dcp : document_creation_property;
FROM
  rep : representation;
WHERE
  wr1: rep.context_of_items.context_type = 'document parameters';
  wr2: rep.name = 'document creation';
SELECT
  dcp.creating_interface := rep::items{descriptive_representation_item | 
                                       name = 'creating interface'}
                                       [1].description;
  dcp.creating_system    := rep::items{descriptive_representation_item | 
                                       name = 'creating system'}
                                       [1].description;
  dcp.operating_system   := rep::items{descriptive_representation_item | 
                                       name = 'operating system'}
                                       [1].description;
END_MAP;

MAP document_size_property_map AS
  dcp : document_size_property;
FROM
  rep : representation;
WHERE
  wr1: rep.context_of_items.context_type = 'document parameters';
  wr2: rep.name = 'document size';
SELECT
  dcp.file_size := value_with_unit_map(rep::items{representation_item |
name = 'file size'}[1]);
  dcp.page_count := value_with_unit_map(rep::items{representation_item |
name = 'page count'}[1]);
END_MAP;

DEPENDENT_MAP document_location_property_map AS
  dlp : document_location_property;
FROM
  src : external_source;
SELECT
  dlp.location_name := src.source_id;
END_DEPENDENT_MAP;

DEPENDENT_MAP external_file_id_and_location_map AS
  efl : external_file_id_and_location;
FROM
  idx : applied_external_identification_assignment;  
SELECT
  efl.external_id := idx.assigned_id;
  efl.location := document_location_property_map(idx.SOURCE);
END_DEPENDENT_MAP;

DEPENDENT_MAP document_type_property_map AS
  dt : document_type_property;
FROM
  dtp : document_type;
SELECT
  dt.document_type_name := dtp.product_data_type;
END_DEPENDENT_MAP;

MAP rectangular_size_map AS
  rs : rectangular_size;
FROM
  px : planar_extent;
WHERE
   wr1 : px.name = 'size format';
SELECT
  rs.density := IF 'AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM' 
                    IN TYPEOF(px)
                THEN
                  value_with_unit_map(px);
                END_IF;
  rs.height := value_with_unit_map(px.size_in_y);
  rs.width  := value_with_unit_map(px.size_in_x);
END_MAP;

MAP named_size_map AS
  rs : named_size;
SUBTYPE OF (rectangular_size_map);
WHERE
   wr2: 'AUTOMOTIVE_DESIGN.DESCRITPITVE_REPRESENTATION_ITEM' IN TYPEOF(px);
SELECT
  nas.size := px.description;
  nas.referenced_standard := classification_system_map(
    px<-items{applied_classification_assignment |
              role.name = 'class system membership'}
      ::assigned_class{class_system}[1]);
END_MAP;

MAP address_map AS
  pdtnet_adr : address;
FROM
  ap214_adr : address;
SELECT
  pdtnet_adr.internal_location       := ap214_adr.internal_location;
  pdtnet_adr.street_number           := ap214_adr.street_number;
  pdtnet_adr.street                  := ap214_adr.street;
  pdtnet_adr.postal_box              := ap214_adr.postal_box;
  pdtnet_adr.postal_code             := ap214_adr.postal_code;
  pdtnet_adr.town                    := ap214_adr.town;
  pdtnet_adr.region                  := ap214_adr.region;
  pdtnet_adr.country                 := ap214_adr.country;
  pdtnet_adr.facsimile_number        := ap214_adr.facsimile_number;
  pdtnet_adr.telephone_number        := ap214_adr.telephone_number;
  pdtnet_adr.telex_number            := ap214_adr.telex_number;
  pdtnet_adr.electronic_mail_address := ap214_adr.electronic_mail_address;
END_MAP;

MAP organization_map AS
  pdtnet_org : organization;
FROM
  ap214_org : organization;
SELECT
  pdtnet_org.organization_name := ap214_org.name;
  pdtnet_org.id                := ap214_org.id;
  pdtnet_org.organization_type := ap214_org.description;
  pdtnet_org.visitor_address   := address_map(ap214_org<- organizations
                                  {organizational_address | description =
                                  'visitor address'}[1]); 
  pdtnet_org.delivery_address  := address_map(ap214_org<-organizations
                                  {organizational_address | description =
                                  'delivery address'}[1]);
  pdtnet_org.postal_address    := address_map(ap214_org<-organizations
                                  {organizational_address | description =
                                  'postal address'}[1]);
END_MAP;

MAP person_map AS
  pdtnet_pers : person;
FROM
  ap214_pers : person;
SELECT
  pdtnet_pers.person_name := ap214_pers.first_name + ' ' +
                             ap214_pers.last_name;
  pdtnet_pers.preferred_business_address := 
                             address_map(ap214_pers<-people
                                         {personal_address}[1]);
END_MAP;

MAP person_in_organization_map AS
  pio : person_in_organization;
FROM
  pao : person_and_organization;
SELECT
  pio.id                      := pao<-items
                                {applied_identification_assignment |  
                                 role.name = 'id'}[1].assigned_id;
  pio.associated_person       := person_map(pao.the_person);
  pio.associated_organization := organization_map(pao.the_organization);
  pio.role                    := pao.name;
  pio.location                := address_map(pao.the_person<-people
                                 {person_and_organization_address |
                                 pao.the_organization IN 
                                 organizations}[1]); 
END_MAP;  

MAP date_time_map AS
  dat : date_time;
PARTITION p_date_and_time;
FROM
  dt : date_and_time;
SELECT
  dat.date := FORMAT(dt.date_component.year_component,'####') + '/' +
              FORMAT(dt.date_component.month_component,'02I') + '/' +
              FORMAT(dt.date_component.day_component,'02I'); 
  dat.time := FORMAT(dt.time_component.hour_component, '02I') + ':' +
              FORMAT(dt.time_component.minute_component, '02I') + ':' +
              FORMAT(dt.time_component.second_component, '02I');
PARTITION p_calendar_date;
FROM
  cd : calendar_date;
WHERE
  SIZEOF(cd<-date_component{date_and_time}) = 0;
SELECT
  dat.date := FORMAT(cd.year_component, '####') + '/' +
              FORMAT(cd.month_component, '02I') + '/' +
              FORMAT(cd.day_component, '02I');
END_MAP;

MAP date_person_organization_map AS
  dpo : date_and_person_organization;
PARTITION p_date_time_pers_org;
FROM
  pao : person_and_organization;
  dta : applied_date_and_time_assignment;
WHERE
  wr1: pao IN dta.items;
  wr2: dta.role.name = 'actual';
SELECT
  dpo.actual_date            := date_time_map(dta.assigned_date_and_time);
  dpo.person_or_organization := person_in_organization_map(pao);
PARTITION p_date_pers_org;
FROM
  apa : applied_person_and_organization_assignment;
  da  : applied_date_assignment;
WHERE
  wr1: apa IN da.items;
  wr2: da.role.name = 'actual';  
SELECT
  dpo.actual_date            := date_time_map(da.assigned_date);
  dpo.person_or_organization := person_in_organization_map(apa.assigned_person_and_organization);
PARTITION p_date_time_org;
FROM
  aoa : applied_organization_assignment;
  dta : applied_date_and_time_assignment;
WHERE
  wr1: aoa IN dta.items;
  wr2: dta.role.name = 'actual';  
SELECT
  dpo.actual_date            := date_time_map(dta.assigned_date_and_time);
  dpo.person_or_organization := organization_map(aoa.assigned_organization);
PARTITION p_date_org;
FROM
  aoa : applied_organization_assignment;
  da  : applied_date_assignment;
WHERE
  wr1: aoa IN da.items;
  wr2: da.role.name = 'actual';  
SELECT
  dpo.actual_date           := date_time_map(da.assigned_date);
  dpo.person_or_organization:= organization_map(aoa.assigned_organization);
PARTITION p_approval_date_time;
FROM  
  apo : approval_person_organization;
  dta : applied_date_and_time_assignment;
WHERE
  wr1: apo IN dta.items;
  wr2: dta.role.name = 'sign off';  
SELECT
  dpo.actual_date            := date_time_map(dta.assigned_date_and_time);
  dpo.person_or_organization := 
                      person_in_organization_map(apo.person_organization);
PARTITION p_approval_date;
FROM  
  apo : approval_person_organization;
  da : applied_date_assignment;
WHERE
  wr1: apo IN da.items;
  wr2: da.role.name = 'sign off';  
SELECT
  dpo.actual_date            := date_time_map(da.assigned_date);
  dpo.person_or_organization := 
            person_in_organization_map(apo.person_organization);
END_MAP;

MAP person_organization_assignment_map AS
  poa : person_organization_assignment;
PARTITION p_org;
FROM
  aoa : applied_organization_assignment;
SELECT
  poa.assigned_person_organization := 
                      organization_map(aoa.assigned_organization);
  poa.role                         := aoa.role.name;
  poa.description                  := aoa.role.description;
  poa.is_applied_to                := FOR EACH it IN aoa.items 
                                        RETURN org_select_map(it);
PARTITION p_pers_org;
FROM
  apa : applied_person_and_organization_assignment;
SELECT
  poa.assigned_person_organization := 
         person_in_organization_map(apa.assigned_person_and_organization);
  poa.role                         := apa.role.name;
  poa.description                  := apa.role.description;
  poa.is_applied_to                := FOR EACH it IN apa.items
                                        RETURN org_select_map(it);
END_MAP;
  
DEPENDENT_MAP org _select_map AS  
  god : general_organizational_data_select;
PARTITION p_item;
FROM
  p : product;
WHERE
  EXISTS(item_map(p));
RETURN item_map(p);
PARTITION p_item_version;
FROM
  pdf : product_definition_formation;
WHERE
  EXISTS(item_version_map(pdf));
RETURN item_version_map(pdf);
PARTITION p_document;
FROM 
  p : product;
WHERE
  EXISTS(document_map(p));
RETURN document_map(p);
PARTITION p_document_version;
FROM
  pdf : product_definition_formation;
WHERE
  EXISTS(document_version_map(pdf));
RETURN document_version_map(pdf);
END_DEPENDENT_MAP;

MAP date_and_person_assignment_map AS
  dpa : date_and_person_assignment;
PARTITION p_date_time_pers_org;
FROM
  aoa : applied_organization_assignment;
  dta : applied_date_and_time_assignment;
WHERE
  wr1: aoa IN dta.items;
  wr2: dta.role.name = 'actual';  
SELECT
  dpa.assigned_date_and_person := date_person_organization_map(aoa, dta);
  dpa.is_applied_to            := FOR EACH it IN aoa.items
                                    RETURN org_select_map(it);
  dpa.role                     := aoa.role.name;
  dpa.description              := aoa.role.description;                                    
PARTITION p_date_pers_org;
FROM
  apa : applied_person_and_organization_assignment;
  da  : applied_date_assignment;
WHERE
  wr1: apa IN da.items;
  wr2: da.role.name = 'actual';  
SELECT
  dpa.assigned_date_and_person := date_person_organization_map(apa, da);
  dpa.is_applied_to            := FOR EACH it IN apa.items
                                    RETURN org_select_map(it);
  dpa.role                     := apa.role.name;
  dpa.description              := apa.role.description;
END_MAP;

MAP date_time_assignment_map AS
  dta : date_time_assignment;
PARTITION p_date_time;
FROM
  adta : applied_date_and_time_assignment;
SELECT
  dta.description := adta.role.description;
  dta.role        := adta.role.name;
  dta.assigned_date_time := data_time_map(adta.assigned_date_and_time);
  dta.is_applied_to := 
    FOR EACH it IN adta.items;
      RETURN (data_time_person_organization_element_select_map(it));
PARTITION p_date;
FROM
  ada : applied_date_assignment;
SELECT
  dta.description := ada.role.description;
  dta.role        := ada.role.name;
  dta.assigned_date_time := data_time_map(ada.assigned_date);
  dta.is_applied_to := 
    FOR EACH it IN ada.items;
      RETURN (data_time_person_organization_element_select_map(it));
END_MAP;

MAP approval_map AS
  tgt : approval;
FROM
  src : approval;
SELECT
  tgt.level          := src.level;
  tgt.status         := approval_status_map(src.status);
  tgt.is_applied_to  := 
    FOR EACH it IN 
      src_app<-assigned_approval{applied_approval_assignment}::items;
      RETURN (approval_element_select_map(it));
  tgt.scope          := 
    organization_map(src<-items{applied_organization_assignment |
                                role.name = 'scope'} 
                        ::assigned_organization{organization}[1]);
  tgt.planned_date:= 
    date_time_map(src<-dated_approval{approval_date_time |
                                      role.name = 'planned'}
                     ::date_time[1]);
  tgt.actual_date    := 
    date_time_map(src<-dated_approval{approval_date_time |
                                      role.name = 'actual'}
                     ::date_time[1]);
  tgt.is_approved_by := FOR EACH it IN 
   src<-authorized_approval{approval_person_organization | 
   approval_person_organization<-items{applied_date_and_time_assignment |
                                       role.name = 'sign off'}};
   RETURN date_person_organization_map(it.person_organization,
            it<-items{applied_date_and_time_assignment}[1]);
END_MAP;

MAP approval_status_map AS
  tgt : approval_status;
FROM
  src : approval_status;
SELECT
  tgt_stat.status_name := src_stat.name;
  tgt_stat.used_classification_system := 
    classification_system_map(
      src<-items{applied_classification_assignment | 
                 role.name = 'class system membership'} 
         :: assigned_class{class_system}[1]);
END_MAP;

MAP approval_relationship_map AS
  tgt_apr : approval_relationship;
FROM
  src_apr : approval_relationship;
SELECT
  tgt_apr.description   := src_apr.description;
  tgt_apr.relation_type := src_apr.name;
  tgt_apr.related       := approval_map(src_apr.related_approval);
  tgt_apr.relating      := approval_map(src_apr.relating_approval);
END_MAP;

MAP item_classification_map AS
  sic : specific_item_classification;
FROM
  prpc : product_related_product_category;
WHERE
  EXISTS(item_map(prpc.products[1]));
SELECT
  sic.associated_item     := FOR EACH p IN prpc.products
                              RETURN item_map(p);
  sic.classification_name := prpc.name;
  sic.description         := prpc.description;
END_MAP;

MAP item_classification_hierarchy_map AS
  ich : specific_item_classification_hierarchy;
FROM
  prpc : product_category_relationship;
WHERE
  EXISTS(item_classification_map(prpc.category));
SELECT
  ich.sub_classification   := item_classification_map(prpc.sub_category);
  ich.super_classification := item_classification_map(prpc.category);
END_MAP;

MAP document_classification_map AS
  sic : specific_document_classification;
FROM
  prpc : product_related_product_category;
WHERE
  EXISTS(document_map(prpc.products[1]));
SELECT
  sic.associated_document := FOR EACH p IN prpc.products
                               RETURN document_map(p);
  sic.classification_name := prpc.name;
  sic.description         := prpc.description;
END_MAP;

MAP document_classification_hierarchy_map AS
  dch : specific_document_classification_hierarchy;
FROM
  prpc : product_category_relationship;
WHERE
  EXISTS(document_classification_map(prpc.category));
SELECT
  dch.sub_classification := document_classification_map(prpc.sub_category);
  dch.super_classification := document_classification_map(prpc.category);
END_MAP;

MAP general_classification_map AS
  gc : general_classification;
FROM
  cl : class;
SELECT
  gc.id := cl\group.name;
  gc.description := cl\group.description;
  gc.version_id := aia<-items{applied_identification_assignment |
                              role.name = 'version'}[1].assigned_id;
  gc.classification_source := 
    IF 'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS' IN TYPEOF(cl) THEN
      external_library_reference_map(cl.SOURCE);
    END_IF; 
  gc.used_classification_system := classification_system_map(
      cl<-items{applied_classification_assignment | 
                role.name = 'class system membership'}
        ::assigned_class{class_system}[1]);
END_MAP;

MAP classification_system_map AS
  cls : classification_system;
FROM
  cs : class_system;
SELECT
  cls.id := cs.name;
  cls.description := cs.description;
END_MAP;

MAP general_classification_hierarchy_map AS
  gch : general_classification_hierarchy;
FROM
  grel : group_relationship;
WHERE
  grel.name = 'class hierarchy';
SELECT
  gch.sub_classification := general_classification_map(grel.related_group);
  gch.super_classification :=
    general_classification_map(grel.relating_group);
END_MAP;

MAP external_library_reference_map AS
  elr : external_library_reference;
FROM
  edi : externally_defined_item;
WHERE
  wr1: SIZEOF(['AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_CLASS',
               'AUTOMOTIVE_DESIGN.EXTERNALLY_DEFINED_PROPERTY'] *
              TYPEOF(edi)) > 0;
  wr2: NOT('AUTOMOTIVE_DESIGN.KNOWN_SOURCE' IN TYPEOF(cls.SOURCE));
SELECT
  elr.description  := edi.SOURCE.description;
  elr.external_id  := edi.item_id;
  elr.library_type := edi.SOURCE.source_id;
END_MAP;

MAP classification_association_map AS
  ca : classification_association;
FROM
  aca : applied_classification_assignment;
SELECT
  ca.definitional := IF aca.role.name = 'non-definitional' THEN
                       FALSE;
                     ELSE
                       IF aca.role.name = 'definitional' THEN
                         TRUE;
                       END_IF;
                     END_IF;
  ca.role := aca.role.description;
  ca.associated_classification := 
    general_classification_map(ca.assigned_class);
  ca.classified_element := classified_element_select_map(aca.items[1]);
END_MAP;

MAP classification_attribute_map AS
  ca : classification_attribute;
FROM
  pd : property_definition;
  cd : characterized_class;
WHERE
  pd.definition :=: cd;
IDENTIFIED_BY pd;
SELECT
  ca.description := pd.description;
  ca.id := pd.id;
  ca.name := pd.name;
  ca.associated_classification := general_classification_map(cd);
  ca.attribute_definition := 
    property_map(pd<-derived_definition{general_property_association |
                                        name = 'attribute definition'}
                   ::base_definition{general_property}[1]);
  ca.allowed_value := property_value_representation_map(
    pd<-represented_definition{property_definition_representation}
      ::used_representation{representation}[1]);
END_MAP;

MAP property_value_association_map AS
  pv : property_value_association ;
PARTITION p_pdef ;
FROM
  pdef : property_definition ;
RETURN (item_property_association_map(pdef)) ;
PARTITION p_act ;
FROM
  apr : action_property ;
RETURN (process_property_association_map(apr));
PARTITION p_res ;
FROM
  res : resource_property ;
RETURN (process_property_association_map(res));
END_MAP ;

MAP item_property_association_map AS
  ipa : item_property_association;
FROM
  pdef : property_definition;
  gpa  : general_property_association;
WHERE
  gpa.derived_definition :=: pdef;
IDENTIFIED_BY pdef;
SELECT
  ipa.described_element := item_property_select_map(pdef.definition);
  ipa.describing_property_value := 
         property_value_rep_map(pdef<-definition
                                {property_definition_representation}[1]);
  ipa.definitional := CASE gpa.name OF 
                        'definitional'     : TRUE;
                        'non-definitional' : FALSE; 
                      END_CASE;
  ipa.description := pdef.description;
  ipa.validity_context := 
    IF SIZEOF(ipa<-items{applied_organization_assignment | 
                         name = 'validity context'}) > 0 THEN
      organization_map(ipa<-items{applied_organization_assignment | 
                                  name = 'validity context'}
                          ::assigned_organization[1]) ;
   ELSE
     IF SIZEOF(ipa<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}) > 0
     THEN
       product_class_map(ipa<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}[1]);
     ELSE
       product_identification_map(ipa<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_identification}[1]);
     END_IF;
   END_IF;
END_MAP;

DEPENDENT_MAP item_property_select_map AS
  ips : item_property_select;
PARTITION p_ddid;
FROM
  pd : product_definition;
WHERE
  pd.frame_of_reference.name = 'part definition';
RETURN ddid_map(pd);
PARTITION p_docrep;
FROM
  pd : product_definition;
WHERE
  pd.frame_of_reference.name = 'digital document definition';
RETURN digital_document_map(pd);
PARTITION p_docfile;
FROM
  df : document_file;
WHERE
  EXISTS(digital_file_map(df));
RETURN digital_file_map(df);
END_DEPENDENT_MAP;

MAP property_map AS
  prop : property;
FROM
  gp : general_property;
SELECT
  prop.id              := gp.id;
  prop.description     := gp.description;
  prop.version_id      := gp<-items{applied_identification_assignment | 
                                    role.name = 'version'}[1].assigned_id;
  prop.allowed_unit := FOR EACH un IN 
                         gp<-definition{property_definition_representation}
                           ::used_representation{representation | 
                                                 name = 'allowed units'}
                           ::context_of_items{global_unit_assigned_context}
                           ::units
                         RETURN unit_map(un);
END_MAP;

MAP mass_property_map AS
  prop : mass_property;
SUBTYPE OF (property_map);
WHERE
  gp.name = 'mass';
END_MAP;

MAP cost_property_map AS
  prop : cost_property;
SUBTYPE OF (property_map);
WHERE
  gp.name = 'cost property';
END_MAP;

MAP duration_property_map AS
  prop : duration_property;
SUBTYPE OF (property_map);
WHERE
  gp.name = 'duration property';
END_MAP;

MAP recyclability_property_map AS
  prop : recyclability_property ;
SUBTYPE OF (propery_map) ;
WHERE
  gp.name = 'recyclability property' ;
END_MAP ;

MAP quality_property AS
  prop : quality_property ;
SUBTYPE OF (propery_map) ;
WHERE
  gp.name = 'quality property' ;
END_MAP ;

MAP material_property_map AS	
  prop : material_property ;	
SUBTYPE OF (property_map);
WHERE
  'AUTOMOTIVE_DESIGN.GENERAL_MATERIAL_PROPERTY' IN TYPEOF(gp) ;
SELECT
  prop.property_name := gp.name ;
END_MAP ;

MAP general_property_map AS
  prop : general_property;
SUBTYPE OF (property_map);
WHERE
  OTHERWISE ;
SELECT
  prop.property_type := gp.name ;
END_MAP;

MAP material_map AS
  ma : material;
FROM
  mdes : material_designation;
SELECT
  ma.material_name := mdes.name;
  ma.described_element := FOR EACH def IN mdes.definitions;
                            RETURN (item_property_select_map(def));
END_MAP;

MAP material_property_association_map AS
  mpa : material_property_association;
FORM
  mdc : material_designation_characterization;
SELECT
  mpa.definitional := IF mdc.name = 'definitional' THEN
                        TRUE;
                      ELSE
                        IF mdc.name = 'non-definitional' THEN
                          FALSE;
                        END_IF;
                      END_IF;
  mpa.associated_property_value := 
    material_property_value_representation_map(
      mdc.property.used_representation);
  mpa.described_material := material_map(mdc.designation);
END_MAP;

MAP property_value_rep_map AS
  pval : property_value_representation;
FROM
  pdef : property_definition;
  pdr  : property_definition_representation;
  gpa  : general_property_association;
  rep  : representation;
WHERE
  wr1: pdr.definition          :=: pdef;
  wr2: gpa.derived_definition  :=: pdef;
  wr3: pdr.used_representation :=: rep;
IDENTIFIED_BY rep;
SELECT
  pval.definition  := property_map(gpa.base_definition);
  pval.global_unit := unit_map(rep
                      ::context_of_items{global_unit_assigned_context}
                      ::units[1]);
  pval.qualifier   := rep::items{qualified_representation_item | 
                                 name = 'qualifier'}
                         ::qualifiers{type_qualifier}[1].name;
  pval.value_determination := rep::items{qualified_representation_item | 
                                         name = 'value interpretation'}
                                 ::qualifiers{type_qualifier}[1].name;
  pval.specified_value := property_value_map(rep::items{representation_item
                            | (name <> 'qualifier') AND 
                              (name <> 'value interpretation')}[1]);
END_MAP;

MAP material_property_value_representation_map AS
  pval : material_property_value_representation;
SUBTYPE OF (property_value_rep_map);
WHERE
  wr4: 'AUTOMOTIVE_DESIGN.MATERIAL_PROPERTY_REPRESENTATION'
       IN TYPEOF(pdr);
SELECT
  pval.environment_condition :=
    data_environment_map(pdr.dependent_environment);
END_MAP;

MAP data_environment_map AS
  t_de : data_environment;
FROM
  s_de : data_environment;
SELECT
  t_de.description := s_de.description;
  t_de.environment_name := s_de.name;
END_MAP;

DEPENDENT_MAP property_value_map AS
  pval : property_value;
FROM
  ri : representation_item;
SELECT
  pval.value_name := ri.name;    
END_DEPENDENT_MAP;

DEPENDENT_MAP string_value_map AS
  pval : string_value;
SUBTYPE OF (property_value_map);
WHERE
  'AUTOMOTIVE_DESIGN.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(ri);
SELECT
  pval.value_specification := ri.description;
END_DEPENDENT_MAP;

DEPENDENT_MAP value_with_unit_map AS
  pval : value_with_unit;
SUBTYPE OF (property_value_map);
WHERE
  OTHERWISE;
SELECT
  pval.significant_digits := ri::qualifiers{precision_qualifier}
                               [1].precision_value;
END_DEPENDENT_MAP;

DEPENDENT_MAP value_limit_map AS
  pval : value_limit;
SUBTYPE OF (value_with_unit_map);
WHERE
  SIZEOF(ri::qualifiers{type_qualifier | 
                        (name = 'maximum') OR 
                        (name = 'minimum')}) > 0;
SELECT
  pval.limit_qualifier := ri::qualifiers{type_qualifier | 
                          (name = 'maximum') OR 
                          (name = 'minimum')}[1].name;
  pval.unit_component  := unit_map(ri::unit_component[1]);
  pval.limit           := ri.value_component;
END_DEPENDENT_MAP;

DEPENDENT_MAP value_range_map AS
  pval : value_range;
SUBTYPE OF (value_with_unit_map);
WHERE
  'AUTOMOTIVE_DESIGN.VALUE_RANGE' IN TYPEOF(ri);
SELECT
  pval.lower_limit    := ri::item_element{representation_item | 
                                          name = 'lower limit'}
                           ::value_component[1];
  pval.upper_limit    := ri::item_element{representation_item | 
                                           name = 'upper limit'}
                           ::value_component[1];
  pval.unit_component := unit_map(ri::item_element{measure_with_unit}
                                    ::unit_component[1]);
END_DEPENDENT_MAP;

DEPENDENT_MAP numerical_value_map AS
  pval : numerical_value;
SUBTYPE OF (value_with_unit_map);
WHERE
  OTHERWISE;
SELECT
  pval.value_component := ri.value_component;
  pval.unit_component  := unit_map(ri::unit_component[1]);
END_DEPENDENT_MAP;

DEPENDENT_MAP unit_map AS
  t_un : unit;
FROM
  s_un : unit;
SELECT
  t_un.unit_name := get_unit_name(s_un);
END_DEPENDENT_MAP;

DEPENDENT_MAP value_list_map AS
  pval : value_list;
SUBTYPE OF (property_value_map);
WHERE
  'AUTOMOTIVE_DESIGN.COMPOUND_REPRESENTATION_ITEM' IN TYPEOF(ri);
SELECT
  pval.values := FOR EACH elem IN ri.item_element;
                   RETURN (property_value_map(elem));
END_DEPENDENT_MAP;

MAP design_constraint_map AS
  dc : design_contraint;
FROM
  pdf : product_definition_formation;
WHERE
  wr1: SIZEOF(pdf<-formation{product_definition | 
              frame_of_reference.name='design contrained definition'}) > 0;
  wr2: SIZEOF(pdf.of_product<-products{product_related_product_category |
                                       name = 'requirement'}) > 0;
SELECT
  dc.constraint_id := pdf.of_product.id;
  dc.description := pdf.description;
  dc.name := pdf.of_product.name;
  dc.is_valid_for := product_class_map(
    pdf<-formation{product_definition |
                   frame_of_reference.name='design constraint definition'}
       <-design{configuration_design | name = 'design constrained usage'}
       ::configuration{configuration_item}
       ::item_concept{product_class}[1]);
END_MAP;

MAP design_contraint_version_map AS
  dc : design_contraint_version;
SUBTYPE OF (design_constraint_map);
WHERE
  wr3: (pdf.id <> '') AND (pdf.id <> '/ANY') AND (pdf.id <> '/NULL');
SELECT
  dc.version_id := pdf.id;
END_MAP;

MAP design_contraint_relationship_map AS
  dcr : design_contraint_relationship;
FROM
  pdr : product_definition_relationship;
WHERE
  wr1: pdr.related_product_definition.frame_of_reference.name = 
      'design contraint definition';
  wr2: pdr.relating_product_definition.frame_of_reference.name = 
       'design contraint definition';
SELECT
  dcr.related := design_contraint_map(pdr.related_product_definition);
  dcr.relating := design_contraint_map(pdr.relating_product_definition);
  dcr.relation_type := pdr.name;
  drc.description := pdr.description;
END_MAP;

MAP design_constraint_association_map AS
  dca : design_constraint_association;
FROM
  pdr : product_definition_relationship;
WHERE
  wr1: pdr.name = 'design contraint association';
  wr2: pdr.relating_product_definition.frame_of_reference.name = 
       'design contraint definition';
  wr3: pdr.related_product_definition.frame_of_reference.name IN 
       ['alternative definition', 'conceptual definition', 
        'functional definition'];
SELECT
  dca.name := pdr.description;
  dca.is_based_on := design_containt_map(pdr.relating_product_definition);
  dca.is_contraining :=complex_product_map(pdr.related_product_definition);
END_MAP;

MAP change_map AS
  ch : change;
PARTITION p_pdr;
FROM
  pdr : product_definition_relationship;
WHERE
  pdr.name = 'change';
SELECT
  ch.description := pdr.description;
  ch.described_change := change_relationship_select_map(pdr);
PARTITION p_pdfr;
FROM
  pdfr : product_definition_formation_relationship;
WHERE
  pdfr.name = 'change';
SELECT
  ch.description := pdfr.description;
  ch.described_change := change_relationship_select_map(pdfr);
PARTITION p_arel;
FROM
  arel : action_relationship;
WHERE
  arel.name = 'change';
SELECT
  ch.description := arel.description;
  ch.described_change := change_relationship_select_map(arel);
PARTITION p_sarel;
FROM
  sarel : shape_aspect_relationship;
WHERE
  sarel.name = 'change';
SELECT
  ch.description := sarel.description;
  ch.described_change := change_relationship_select_map(sarel);
END_MAP;

MAP item_shape_map AS
  is : item_shape;
FROM
  pds : product_definition_shape;
WHERE
  pds.definition.frame_of_reference.name = 'part definition';
SELECT
  is.description      := pds.description;
  is.described_object := ddid_map(pds.definition);
END_MAP;

MAP shape_description_association_map AS
  sda : shape_description_association;
FROM 
  sdr : shape_definition_representation;
WHERE 
  sdr.definition.definition.frame_of_reference.name = 'part definition';
SELECT
  sda.is_defining_shape_for := 
               IF 'AUTOMOTIVE_DESIGN.SHAPE_ASPECT' 
                  IN TYPEOF(sdr.definition.definition)
               THEN
                 shape_element_map(sdr.definition.definition);
               ELSE
                 item_shape_map(sdr.definition);
               END_IF;
  sda.defining_geometry := geometric_model_map(sdr.used_representation);
  sda.role              := sdr.name;
END_MAP;

MAP geometric_model_map AS
  gm : geometric_model;
FROM
  sr : shape_representation;
WHERE
  sr.context_of_items.context_type <> 'external';
SELECT
  gm.description := sr.description ;
  gm.model_extent := sr<-rep_1{representation_relationship | 
                               name = 'model extent association'} 
                       ::rep_2{representation | 
                               name = 'model extent representation'} 
                       ::items{representation_item | 
                               name = 'model extent value'}
                       ::value_component;
  gm.model_id     := sr.id;

  gm.is_defined_in := 
    cartesian_coordinate_space_map(sr.context_of_items);
END_MAP;

MAP external_model_map AS
  emod : external_model;
FROM
  rep : representation;
WHERE
  wr1 : rep.context_of_items.context_type = 'external';
  wr2 : SIZEOF(rep::items{axis2_placement_3d} +
               rep::items{axis2_placement_2d}) > 0 ;
SELECT
  emod.model_id      := rep.name;
  emod.description   := rep.description ;
  emod.is_defined_as := 
       digital_file_map(sr<-used_representation
                        {property_definition_representation}
                        ::definition{property_definition | 
                                     name = 'external definition'}
                        ::definition{document_file}[1]);
  emod.is_defined_in := 
    cartesian_coordinate_space_map(sr.context_of_items);
END_MAP;

MAP external_geometric_model_map AS
  emod : external_geometric_model ;
SUBTYPE OF (external_model_map) ;
WHERE
  'AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' IN TYPEOF(rep);
SELECT
  emod.model_extent := sr<-rep_1{representation_relationship | 
                               name = 'model extent association'} 
                       ::rep_2{representation | 
                               name = 'model extent representation'} 
                       ::items{representation_item | 
                               name = 'model extent value'}
                       ::value_component;
END_MAP;

MAP external_picture_map AS
  emod : external_picture ;
SUBTYPE OF (external_model_map) ;
WHERE
  wr1 : 'AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_CONTEXT'
         IN TYPEOF(rep.context_of_items);
  wr2 : rep.context_of_items.coordinate_space_dimension = 2;
END_MAP;

MAP cartesian_coordinate_space_map AS
  ccs : cartesian_coordinate_space;
FROM
  grc : geometric_representation_context;
SELECT
  ccs.unit_of_values := FOR EACH un IN grc.units;
                          RETURN unit_map(un);   
END_MAP;

MAP cartesian_coordinate_space_2d_map AS
  ccs : cartesian_coordinate_space_2d;
SUBTYPE OF (cartesian_coordinate_space_map);
WHERE
  grc.coordinate_space_dimension = 2 ;
END_MAP;

MAP cartesian_coordinate_space_3d_map AS
  ccs : cartesian_coordinate_space_3d;
SUBTYPE OF (cartesian_coordinate_space_map);
WHERE
  grc.coordinate_space_dimension = 3 ;
END_MAP;

MAP accuracy_map AS
  ac : accurracy;
PARTITION p_gl;
FROM
  gl : global_uncertainty_assigned_context;
SELECT
  ac.accuracy_type := gl.name;
  ac.accuracy_value := 
    gl::uncertainty{uncertainty_measure_with_unit}[1].value_component;
  ac.description :=
    gl::uncertainty{uncertainty_measure_with_unit}[1].description;
  ac.is_defined_for := 
    geometric_model_map(gl<-context_of_items{shape_representation}[1]);
PARTITION p_uar;
FROM
  uar : uncertainty_assigned_context;
SELECT
  ac.accuracy_type := uar.name;
  ac.accuracy_value :=
    uar::uncertainty{uncertainty_measure_with_unit}[1].value_component;
  ac.description :=
    uar::uncertainty{uncertainty_measure_with_unit}[1].description;
  ac.is_defined_for := geometric_model_map(uar);
PARTITION p_qual;
FROM
  qrep : qualified_representation_item;
  stu: standard_uncertainty;
WHERE
  stu IN qrep.qualifiers;
IDENTIFIED_BY qrep;
SELECT
  ac.accuracy_type := stu.measure_name;
  ac.accuracy_value := stu.uncertainty_value;
  ac.description := stu.description;
END_MAP;

MAP shape_element_map AS
  se : shape_element;
FROM
  sa : shape_aspect;
SELECT
  se.description  := sa.description;
  se.element_name := sa.name;
  se.composition  := item_shape_map(sa.of_shape);
END_MAP;

MAP shape_element_relationship_map AS
  ser : shape_element_relationship;
FROM
  sar : shape_aspect_relationship;
SELECT
  ser.description := sar.description;
  ser.relation_type := sar.name;
  ser.related := shape_element_map(sar.related_shape_aspect);
  ser.relating := shape_element_map(sar.relating_shape_aspect);
END_MAP;

MAP model_relationship_map AS
  gmr : geometric_model_relationship;
FROM
  srr : shape_representation_relationship;
SELECT
  gmr.relating      := geometric_model_map(srr.rep_2);
  gmr.related       := geometric_model_map(srr.rep_1);
  gmr.relation_type := srr.name;
END_MAP;

MAP model_relationship_trafo_map AS
  gmr : geometric_model_relationship_with_transformation
SUBTYPE OF (model_relationship_map);
WHERE
  'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION'
   IN TYPEOF(srr);
SELECT
  gmr.model_placement := 
    transformation_map(srr.transformation_operator);
END_MAP;

MAP transformation_map AS
  tr : transformation_3d;
PARTITION p_mapped;
FROM
  mit : mapped_item ;
RETURN (mapped_item_map(idt));
PARTITION p_idt ;
FROM
  idt : item_defined_transformation ;
RETURN (implicit_transformation_3d_map(idt));
PARTITION p_fdt ;
FROM
  pdt: cartesian_transformation_operator_3d;
RETURN (explicit_transformation_3d_map(idt));
END_MAP;

DEPENDENT_MAP implicit_transformation_3d_map AS
  tr : implicit_transformation_3d;
FROM
  idt : item_defined_transformation ;
SELECT
  tr.transformation_target := axis_placement_map(trop.transform_item_2);  
  tr.transformation_origin := axis_placement_map(trop.transform_item_1); 
END_DEPENDENT_MAP;

DEPENDENT_MAP explicit_transformation_3d_map AS
  tr : explicit_transformation_3d;
FROM
  cto : cartesian_transformation_operator_3d ;
SELECT
  tr.axis1 := direction_map(trop.axis1);
  tr.axis2 := direction_map(trop.axis2);
  tr.axis3 := direction_map(trop.axis3);
  tr.local_origin := cartesian_point_map(trop.local_origin);
END_DEPENDENT_MAP;

DEPENDENT_MAP mapped_item_map AS
  tr : transformation_3d ;
FROM
  mi : mapped_item ;
END_DEPENDENT_MAP ;

DEPENDENT_MAP mapped_item_explicit_trafo_map AS
  tr : explicit_transformation_3d;
SUBTYPE OF (mapped_item_map) ;
WHERE
  'AUTOMOTIVE_DESIGN.CARTESIAN_TRANSFORMATION_3D' IN 
  TYPEOF(mi.mapping_target) ;
SELECT
  tr.axis1 := direction_map(mi.mapping_target.axis1);
  tr.axis2 := direction_map(mi.mapping_target.axis2);
  tr.axis3 := direction_map(mi.mapping_target.axis3);
  tr.local_origin := cartesian_point_map(mi.mapping_target.local_origin);
END_DEPENDENT_MAP ;

DEPENDENT_MAP mapped_item_implicit_trafo_map AS
  tr : implicit_tranformation_3d ;
SUBTYPE OF (mapped_item_map) ;
WHERE
  'AUTOMOTIVE_DESIGN.AXIS2_PLACEMENT_3D' IN TYPEOF(mi.mapping_target) ;
SELECT
  tr.transformation_target := axis_placement_map(mi.mapping_target);
  tr.transformation_origin := axis_placement_map(mi.mapping_origin);
END_DEPENDENT_MAP ;

MAP axis_placement_map AS
  t_axpl : axis2_placement_3d;
FROM
  s_axpl : axis2_placement_3d;
SELECT
  t_axpl.location      := cartesian_point_map(s_axpl.location);
  t_axpl.ref_direction := direction_map(s_axpl.ref_direction);
  t_axpl.axis          := direction_map(s_axpl.axis);  
END_MAP;

MAP cartesian_point_map AS
  t_cp : cartesian_point;
FROM
  s_cp : cartesian_point;
SELECT
  t_cp.coordinates := s_cp.coordinates;
END_MAP;

MAP direction_map AS
  t_dr : direction;
FROM
  s_dr : direction;
SELECT
  t_dr.direction_ratios := s_dr.direction_ratios;
END_MAP;    

MAP activity_map AS
  acv : activity;
FROM
  act : executed_action;
LOCAL
  dpos : SET OF date_and_person_organization;
END_LOCAL;
SELECT
  acv.activity_type := act.name;
  acv.description   := act.description;
  acv.id            := act.id;
  acv.internal      := CASE act.chosen_method.purpose OF
                         'internal' : TRUE;
                         'external' : FALSE;
                       OTHERWISE : ?;
                       END_CASE;
  acv.status        := act<-assigned_action{action_status}[1].status;
  acv.chosen_method := activity_method_map(act.chosen_method);
  acv.actual_end_date := date_time_map(
                           (act<-items{applied_date_and_time_assignment |
                                       role.name = 'actual end'}
                               ::assigned_date_and_time +
                            act<-items{applied_date_assignment |
                                       role.name = 'actual end'}
                               ::assigned_date)(*[1]*));
  acv.actual_start_date := date_time_map(
                           (act<-items{applied_date_and_time_assignment |
                                       role.name = 'actual start'}
                               ::assigned_date_and_time +
                            act<-items{applied_date_assignment |
                                       role.name = 'actual start'}
                               ::assigned_date)(*[1]*));
  acv.planned_end_date := date_time_map(
                           (act<-items{applied_date_and_time_assignment |
                                       role.name = 'planned end'}
                               ::assigned_date_and_time +
                            act<-items{applied_date_assignment |
                                       role.name = 'planned end'}
                               ::assigned_date)(*[1]*));
  acv.planned_start_date     := date_time_map(
                           (act<-items{applied_date_and_time_assignment |
                                       role.name = 'planned start'}
                               ::assigned_date_and_time +
                            act<-items{applied_date_assignment |
                                       role.name = 'planned start'}
                               ::assigned_date)(*[1]*));
  acv.concerned_organization := 
    FOR EACH org IN act<-items{applied_organization_assignment | 
                               role.name = 'concerned organization'}
                       ::assigned_organization;
      RETURN (organization_map(orig));
  acv.supplying_organization :=
    FOR EACH org IN act<-items{applied_organization_assignment | 
                               role.name = 'supplying organization'}
                       ::assigned_organization;
      RETURN (organization_map(orig));
  acv.requestor := person_organization_map(
                    act<-items{applied_person_and_organization_assignment |
                               role.name = 'requestor'}
                       ::assigned_person_and_organization[1]); 
END_MAP;

MAP activity_relationship_map AS
  actirel : activity_relationship ;
FROM
  actrel : action_relationship ;
SELECT
  actirel.related := activity_map(actrel.related_action) ;
  actirel.relating := activity_map(actrel.relating_action) ;
  actirel.relation_type := actrel.name ;
  actirel.description := actrel.description ;
END_MAP ;

MAP activity_method_map AS
  am : activity_method ;
FROM
  actm : action_method ;
SELECT
  am.consequence := actm.consequence ;
  am.description := actm.description ;
  am.name        := actm.name ;
END_MAP ;

MAP activity_element_map AS
  ae : activity_element ;
FROM
  aaa : applied_action_assignment ;
WHERE
  aaa.role.description = 'activity element' ;
SELECT
  ae.role := aaa.role.name ;
  ae.associated_activity := activity_map(aaa.assigned_action) ;
  ae.element := activity_element_select_map(aaa.items[1]) ;
END_MAP ;

MAP work_request_map AS
  wr : work_request ;
FROM
  va : versioned_action_request ;
  ar : action_request_status ;
WHERE
  ar.assigned_request :=: va ;
SELECT
  wr.description := va.description ;
  wr.id := va.id ;
  wr.request_type := va.purpose ;
  wr.status := ar.status ;
  wr.version_id := va.version_id ;
  wr.scope := 
    FOR EACH it IN 
      vaq<-assigned_action_request{applied_action_request_assignment |
                                   role.name = 'scope'}::items ;
      RETURN (activity_element_select_map(it));
  wr.notified_person := 
    FOR EACH po IN act<-items{applied_person_and_organization_assignment |
                              role.name='notified person or organization'}
                       ::assigned_person_and_organization;
      RETURN (person_organization_map(po)) ;
  wr.requestor := person_organization_map(
                    act<-items{applied_person_and_organization_assignment |
                               role.name = 'requestor'}
                       ::assigned_person_and_organization[1]);
END_MAP ;

MAP activity_method_assignment_map AS
  ara : activity_method_assignment ;
FROM
  ars : action_request_solution ;
SELECT
  ara.relation_type := ars.name ;
  ara.assigned_method := activity_method_map(ars.method) ;
  ara.associated_request := work_request_map(ars.request) ;
END_MAP ;

MAP work_order_map AS
  wo : work_order ;
FROM
  ad : action_directive ;
SELECT
  wo.description     := ad.comment;
  wo.id              := ad.name;
  wo.work_order_type := ad.description;
  wo.version_id      := ad<-items{applied_identification_assignment |
                                  role.name = 'version'} ::assigned_id[1] ;
  wo.is_controlling := FOR EACH da IN adr<-directive{directed_action};
                         RETURN (activity_map(da));
END_MAP ;

MAP project_map AS
  pro : project;
FROM
  opr : organizational_project;
SELECT
  pro.description := opr.description;
  pro.id := opr.id;
  pro.name := opr.name;
  pro.work_program := activity_map(opr<-assigned_organizational_project
                                        {organizational_product_assignment|
                                         role.name = 'work program'}
                                      ::items{executed_action}[1]);
  pro.is_applied_to := FOR EACH it IN 
                          opr<-assigned_organizational_project
                               {organizational_product_assignment |
                                role.name = 'affected item'}::items;
                         RETURN (project_information_select_map(it));
END_MAP;

MAP project_relationship_map AS
  prel : project_relationship;
FROM
  orel : organizational_project_relationship;
SELECT
  prel.related := project_map(orel.related_organizational_project);
  prel.relating := project_map(orel.relating_organizational_project);
  prel.relation_type := orel.name;
  prel.description := orel.description;
END_MAP;

MAP element_delivery_map AS
  t_ed : element_delivery;
FROM
  s_ed : element_delivery;
SELECT
  t_ed.deliverable_element := 
    activity_element_map(s_ed<-assigned_action{applied_action_assignment |
                                        role.name = 'delivarable element'}
                             ::items{applied_action_assignment | 
                               role.description = 'activity element'}[1]);
  t_ed.destination := 
    organization_map(s_ed<-items{applied_organization_assignment |
                     role.name = 'destination'}::assigned_organization[1]);
  t_ed.quantity := 
    value_with_unit_map(t_ed<-definition{action_property}
                            <-property{action_property_representation}
                            ::respresentation{representation | 
                               name = 'derlivery quantity'}::items[1]);
END_MAP;

MAP product_class_map AS
  arm_pcl : product_class;
FROM
  aim_pcl : product_class;
SELECT
  arm_pcl.id          := aim_pcl.id;
  arm_pcl.name        := aim_pcl\product_concept.name;
  arm_pcl.description := aim_pcl\product_concept.description;
  arm_pcl.level_type  := aim_pcl\characterized_object.name;
  arm_pcl.version_id  := aim_pcl<-items{applied_identification_assignment |
                                   role.name = 'version'} ::assigned_id[1];
END_MAP;

MAP class_structure_rel_map AS
  csr : class_structure_relationship;
FROM
  cd : configuration_design;
WHERE
  wr1: 'AUTOMOTIVE_DESIGN.PRODUCT_CLASS' IN 
       TYPEOF(cd.configuration.item_concept);
  wr2: cd.design.frame_of_reference IN ['conceptual definition',
                                        'functional definition'];
SELECT
  csr.relation_type := cd.name ;
  csr.description   := cd.description ;
  csr.related       := IF cd.design.frame_of_reference.name = 
                          'conceptual definition'
                       THEN
                         product_component_map(cd.design.formation) ;
                       ELSE
                         product_function_map(cd.design.formation) ;
                       END_IF;
  csr.relating      := product_class_map(cd.configuration.item_concept);
END_MAP;

MAP complex_product_map AS
  cp : complex_product;
FROM
  pdf : product_definition_formation;
  pd  : product_definition;
WHERE
  wr1: pd.formation :=: pdf;
  wr2: pd.frame_of_reference.name IN
       ['conceptual definition','functional definition',
        'alternative definition'];
IDENTIFIED_BY pdf;
SELECT
  cp.id          := pdf.of_product.id;
  cp.version_id  := pdf.id;
END_MAP;

MAP product_component_map AS
  cp : product_component;
SUBTYPE OF (complex_product_map);
WHERE
  pd.frame_of_reference.name = 'conceptual definition';
SELECT
  cp.instance_required := IF pd.name = 'instance required' THEN
                            TRUE;
                          ELSE
                            IF pd.name = 'no instance required' THEN
                              FALSE;
                            END_IF;
                          END_IF;
  cp.name := pdf.of_product.name;
  cp.description := pdf.description;
  cp.is_relevant_for := 
    FOR EACH pdc IN pd<-definition{product_definition_context_association | 
                                  role.name = 'application context'}
                      ::frame_of_reference{product_definition_context};
     RETURN (app_context_map(pdc));
END_MAP;

MAP product_function_map AS
  cp : product_function;
SUBTYPE OF (complex_product_map);
WHERE
  pd.frame_of_reference.name = 'functional definition';
SELECT
  cp.name := pdf.of_product.name;
  cp.description := pdf.description;
  cp.is_relevant_for := 
    FOR EACH pdc IN pd<-definition{product_definition_context_association | 
                                  role.name = 'application context'}
                      ::frame_of_reference{product_definition_context};
     RETURN (app_context_map(pdc));
END_MAP;

MAP alternative_solution_map AS
  cp : alternative_solution;
SUBTYPE OF (complex_product_map);
WHERE
  pd.frame_of_reference.name = 'alternative definition';
SELECT
  cp.base_element := 
    complex_product_map(
      pd<-related_product_definition{product_definition_relationship | 
                             name = 'solution alternative definition'}
        ::relating_product_definition::formation[1]);
END_MAP;

MAP supplier_solution_map AS
  cp : supplier_solution;
SUBTYPE OF (alternative_solution_map);
WHERE
  pd.name = 'supplier';
SELECT
  cp.supplier := 
    organization_map(pd<-items{applied_organization_assignment | 
                               role.name = 'supplier'}[1]);
  cp.probability_rate := 
    pd<-definition{property_definition}
      <-definition{property_definition_representation}
      ::used_representation{representation | name = 'supplier probability'}
      ::items{measure_representation_item | name = 'probability rate'}
      [1].value_component;
END_MAP;

MAP final_solution_map AS
  cp : final_solution;
SUBTYPE OF (alternative_solution_map);
WHERE
  pd.name = 'final'; 
SELECT
  cp.final_status := 
    pd<-definition{property_definition }
      <-definition{property_definition_representation}
      ::used_representation{representation |
                            name = 'final item characteristics'}
      ::items{descriptive_representation_item | name='final item status'}
      [1].description;
  cp.final_specification := FOR EACH pd IN
    pd<-relating_product_definition{product_definition_relationship |
                                    name = 'final specification'}
       ::related_product_definition{product_definition |
                                    frame_of_reference.name IN
                                    ['part definition',
                                     'physical occurrence']};
      RETURN IF pd_fs.frame_of_reference.name = 'part definition' THEN
                ddid_map(pd_fs);
              ELSE
                physical_instance_map(pd);
              END_IF; 
END_MAP;

MAP technical_solution_map AS
  cp : technical_solution;
SUBTYPE OF (alternative_solution_map);
WHERE
  pd.name = 'technical'; 
SELECT
  cp.description := pdf.description;
END_MAP;

MAP complex_product_relationship_map AS
  cpr : complex_product_relationship;
FROM
  pdfr : product_definition_formation_relationship;
WHERE
  wr1: EXISTS(complex_product_map(
                pdrf.relating_product_definition_formation));
  wr2: EXISTS(complex_product_map(
                pdrf.related_product_definition_formation));
SELECT
  cpr.relation_type := pdfr.name;
  cpr.description   := pdfr.description;
  cpr.relating := 
    complex_product_map(pdrf.relating_product_definition_formation);
  cpr.related  := 
    complex_product_map(pdrf.related_product_definition_formation);
END_MAP;

MAP product_structure_relationship_map AS
  cpr : product_structure_relationship;
FROM
  pdu : product_definition_usage;
WHERE
  wr1: EXISTS(complex_product_map(
                pdrf.relating_product_definition.formation));
  wr2: EXISTS(complex_product_map(
                pdrf.related_product_definition.formation)) OR
       EXISTS(item_instance_map(pdrf.related_product_definition));
SELECT
  cpr.relation_type := pdu.name;
  cpr.description   := pdu.description;
  cpr.relating := 
    complex_product_map(pdu.relating_product_definition.formation);
  cpr.related  := 
    IF EXISTS(item_instance_map(pdu.related_product_definition))
    THEN
      item_instance_map(pdu.related_product_definition);
    ELSE
      complex_product_map(pdu.related_product_definition.formation);
    END_IF;
END_MAP;

MAP item_function_association_map AS
  ifa : item_function_association;
FROM
  pdr : product_definition_relationship;
WHERE
  wr1: pdr.relating_product_definition.frame_of_reference.name = 
       'functional definition';
  wr2: pdr.related_product_definition.frame_of_reference.name =
       'part definition';
SELECT
  ifa.associated_function := 
    product_function_map(pdr.relating_product_definition.formation);
  ifa.assoicated_item := ddid_map(pdr.related_product_definition);
  ifa.association_type := pdr.name;
  ifa.description      := pdr.description;
END_MAP;

MAP class_inclusion_association_map AS
  cia : class_inclusion_association;
FROM
  pcfa : product_concept_feature_association;
  icf  : inclusion_product_concept_feature;
WHERE
  pcfa.feature :=: icf;
IDENTIFIED_BY pcfa;
SELECT
  cia.description := pcfa.description;
  cia.associated_product_class := product_class_map(pcfa.concept);
  cia.associated_inclusion := specification_inclusion_map(icf);
END_MAP;

MAP class_condition_association_map AS
  cia : class_condition_association;
FROM
  pcfa : product_concept_feature_association;
  ccf : conditional_concept_feature;
WHERE
  pcfa.feature :=: ccf;
IDENTIFIED_BY pcfa;
SELECT
  cia.description := pcfa.description;
  cia.condition_type := pcfa.name;
  cia.associated_product_class := product_class_map(pcfa.concept);
  cia.associated_condition := specification_expression_map(ccf);
END_MAP;

MAP class_specification_association_map AS
  csa : class_specification_association;
FROM
  pcfa : product_concept_feature_association;
  pcf  : product_concept_feature;
WHERE
  wr1: pcfa.feature :=: pcf;
  wr2: NOT('AUTOMOTIVE_DESIGN.CONDITIONAL_CONCEPT_FEATURE' IN
           TYPEOF(pcf));
  wr3: NOT('AUTOMOTIVE_DESIGN.INCLUSION_CONCEPT_FEATURE' IN
           TYPEOF(pcf));
SELECT
  csa.association_type := pcfa.name;
  csa.associated_product_class := product_class_map(pcfa.concept);
  csa.associated_specification := specification_map(pcf);
END_MAP;

MAP class_category_assocation_map AS
  cca : class_category_assocation;
FROM
  pcfc : product_concept_feature_category_usage;
SELECT
  cca.mandatory := IF pcfc.role.name = 'mandatory category usage' THEN
                     TRUE;
                   ELSE
                     IF pcfc.role.name = 'optional category usage' THEN
                       FALSE;
                     END_IF;
                   END_IF;
  cca.associated_product_class := product_class_map(pcfc.items[1]);
  cca.associated_category := 
     specification_category_map(pcfc.assigned_group);
END_MAP;

MAP specification_category_map AS
  sc : specification_category;
FROM
  pcfc : product_concept_feature_category;
SELECT
  sc.description := pcfc.description;
  sc.id          := pcfc.id;
  sc.implicit_exclusive_condition := 
    IF 'AUTOMOTIVE_DESIGN.EXCLUSIVE_CONCEPT_FEATURE_CATEGORY' 
        IN TYPEOF(pcfc)
    THEN
      TRUE;
    ELSE
      FALSE;
    END_IF;
END_MAP;

MAP specification_category_hierarchy_map AS
  sch : specification_category_hierarchy;
FROM
  grel : group_relationship;
WHERE
  grel.name = 'specification category hierarchy';
SELECT
  sch.super_category := specification_category_map(grel.relating_group);
  sch.sub_category   := specification_category_map(grel.related_group);
END_MAP;

MAP specification_inclusion_map AS
  si : specification_inclusion;
FROM
  ipcf : inclusion_product_concept_feature;
SELECT
  si.description := ipcf.description;
  si.id := ipcf.id;
  si.if_condition := specification_operand_map(
                       ipcf.condition.relating_product_concept_feature);
  si.included_specification := specification_operand_map(
                       ipcf.condition.related_product_concept_feature);
END_MAP;

MAP specification_operand_map AS
  sp : specification_operand_select;
FROM
  pcf : product_concept_feature;
END_MAP;

MAP specification_expression_map AS
  sp : specification_expression;
SUBTYPE OF (specification_operand_map);
WHERE
  wr1: 'AUTOMOTIVE_DESIGN.CONDITIONAL_CONCEPT_FEATURE' IN TYPEOF(pcf);
SELECT
  sp.id          := pcf.id;
  sp.description := pcf.description;
  sp.OPERATION   := pcf.condition.conditional_operator.name;
  sp.operand     := FOR EACH op IN 
                     ([pcf.condition.related_product_concept_feature, 
                      pcf.condition.relating_product_concept_feature]);
                      RETURN (specification_operand_map(op));
END_MAP;

MAP specification_map AS
  sp : specification;
SUBTYPE OF (specification_operand_map);
WHERE
  OTHERWISE;
SELECT
  sp.id          := pcf.id;
  sp.description := pcf.description;
  sp.package     := 'AUTOMOTIVE_DESIGN.PACKAGE_CONCEPT_FEATURE' 
                    IN TYPEOF(pcf);
  sp.name        := pcf.name; 
  sp.version_id  := aia<-items{applied_identification_assignment |
                               role.name = 'version'}[1].assigned_id;
  sp.category    := 
    specification_category_map(pcf<-items{applied_group_assignment |
                   role.name = 'specification category member'}
                 ::assigned_group{product_concept_feature_category}[1]);
END_MAP;

MAP configuration_map AS
  cfg : configuration;
FROM
  cea : configured_effectivity_assignment;
LOCAL
  pcfa : product_context_feature_association;
END_LOCAL;
WHERE
  cea.assigned_effectivity.id = 'configuration validity';
SELECT
  cfg.configuration_type := cea.role.name;
  cfg.inheritance_type   := cea.role.description;
  
  cfg.configured_element := 
    IF 'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION' IN TYPEOF(cea.items[1])
    THEN
      CASE cea.items[1].frame_of_reference.name OF
       'alternative definition',
       'conceptual definition', 
       'functional definition' : complex_product_map(cea.items[1]);
       'part occurrence'       : item_instance_map(cea.items[1]);
      END_CASE;
    END_IF;
  pcfa := cea<-assigned_effectivity_assignment
          {configured_effectivity_context_assignment | 
          role.name = 'specification based condition'}
          ::items{product_context_feature_association}[1];
  cfg.is_solution_for := 
    IF 'AUTOMOTIVE_DESIGN.CONDITIONAL_CONCEPT_FEATURE' IN
       TYPEOF(pcfa.feature) 
    THEN
      class_condition_association_map(pcfa);
    ELSE
      class_specification_association_map(pcfa);
    END_IF;
END_MAP;

MAP product_design_map AS
  pdes : product_design;
FROM
  cd : configuration_design;
WHERE
  cd.name = 'product design';
SELECT
  pdes.design  := item_version_map(cd.design);
  pdes.product := product_identification_map(cd.configuration);
END_MAP;

MAP product_identification_map AS
  t_pid : product_identification;
FROM
  s_pid : product_identification;
SELECT
  t_pid.id   := s_pid.id;
  t_pid.name := s_pid.name;
  t_pid.description := s_pid.description;
  t_pid.version_id := s_pid<-items{applied_identification_assignment |
                                   role.name = 'version'}[1].assigned_id;
  t_pid.associated_product_class := product_class_map(s_pid.item_concept);
END_MAP;

MAP product_specification_map AS
  t_pid : product_specification;
SUBTYPE OF (product_identification_map);
WHERE
  'AUTOMOTIVE_DESIGN.PRODUCT_SPECIFICATION' IN TYPEOF(s_pid);
SELECT
  t_pid.defining_specification := 
    FOR EACH pcf IN s_pid.item_concept_feature::feature;
      RETURN (specification_map());
END_MAP;

MAP physical_instance_map AS
  phi : physical_instance;
FROM
  pd : product_definition;
WHERE
  pd.frame_of_reference.name = 'physical occurrence';
SELECT
  phi.description := pd.formation.of_product.description;
  phi.inventory_number := 
    pd.formation.of_product<-items{applied_identification_assignment |
                      role.name = 'inventroy number'}[1].assigned_id;
  phi.lot_id := 
    pd.formation.of_product<-items{applied_identification_assignment |
                      role.name = 'lot context'}[1].assigned_id;
  phi.serial_number := pd.formation.of_product.id;
  phi.is_realization_of := 
    IF SIZEOF(pd<-related_product_definition
              {product_definition_relationship | 
               name = 'physical realization'}) > 0 
    THEN
      ddid_map(pd<-related_product_definition
              {product_definition_relationship | 
               name = 'physical realization'}
              ::relating_product_definition[1]);
   ELSE
     product_identification_map(pd<-design{configuration_design |
                                name ='physical instance basis'}
                                ::configuration[1]);
   END_IF;
END_MAP;

MAP physical_instance_test_result_map AS
  pitr : physical_instance_test_reslult;
FROM
  prd : property_definition;
WHERE
  prd.name = 'test result';
SELECT
  pitr.description := prd.description;
  pitr.id := prd.id;
  pitr.tested_instance := physical_instance_map(prd.definition);
  pitr.test_result     := 
    property_value_representation_map(prd<-definition
                                      {property_definition_representation}
                                     ::used_representation[1]);
  pitr.test_activity := 
    IF SIZEOF(pd<-items{applied_action_assignment | 
                        role.name = 'test activity'}
                ::assigned_action{action}
                <-related_action{action_relationship |
                                 name = 'process operation occurrence'}) > 0
    THEN
     process_operation_occurrence_map(
       pd<-items{applied_action_assignment | 
                 role.name = 'test activity'}
         ::assigned_action{action}
         <-related_action{action_relationship |
                          name = 'process operation occurrence'}[1]);
    ELSE
      activity_map(pd<-items{applied_action_assignment | 
                   role.name = 'test activity'}
                   ::assigned_action{executed_action}[1]);
    END_IF;
END_MAP;

MAP physical_assembly_relationship_map AS
  par : physical_assembly_relationship;
FROM
  acu : assembly_component_usage;
WHERE
  acu.name = 'physical occurrence usage';
SELECT
  par.physical_assembly := 
    physical_instance_map(acu.relating_product_definition);
  par.physical_component := 
    physical_instance_map(acu.related_product_definition);
  par.is_realization_of := 
    item_instance_map(acu.related_product_definition
      <-related_product_definition{product_definition_relationship
                                   | name = 'physical realization'}
     ::relating_product_definition[1]);
END_MAP;

MAP process_plan_map AS
  pp : process_plan;
FROM
  ppp : process_plan;
SELECT
  pp.description := ppp.description;
  pp.name := ppp.name;
  pp.plan_id := ppp.id;
  pp.produced_output := 
    item_version_map(ppp<-process{process_product_association | 
                                  name = 'produced output'}
                        ::defined_product{product_definition}
                        ::formation[1]);
END_MAP;

MAP process_plan_version_map AS
  pp : process_plan_version;
SUBTYPE OF (process_plan_map);
WHERE
  SIZEOF(ppp<-items{applied_identification_assignment | 
                    role.name = 'version'}) > 0;
SELECT
  pp.version_id := ppp<-items{applied_identification_assignment | 
                              role.name = 'version'}[1].assigned_id;
END_MAP;

MAP process_plan_relationship_map AS
  ppr : process_plan_relationship;
FROM
  arel : action_relationship;
WHERE
  wr1: 'AUTOMOTIVE_DESIGN.PROCESS_PLAN' IN TYPEOF(arel.related_action);
  wr2: 'AUTOMOTIVE_DESIGN.PROCESS_PLAN' IN TYPEOF(arel.relating_action);
SELECT
  ppr.related := process_plan_map(arel.related_action);
  ppr.relating := process_plan_map(arel.relating_action);
  ppr.relation_type := arel.name;
  ppr.description := arel.description;
END_MAP;

MAP process_operation_definition_map AS
  pod : process_operation_definition;
FROM
  po : process_operation;
SELECT
  pod.description := po.description;
  pod.id := po.name;
  pod.name := po.purpose;
  pod.process_type := po.consequence;
  pod.version_id := po<-items{applied_identification_assignment |
                              role.name = 'version'}[1].assigned_id;
END_MAP;

MAP process_operation_occurrence_map AS
  poo : process_operation_occurrence;
FROM
  arel : action_relationship;
SELECT
  poo.id := arel.related_action.id;
  poo.operation_definition := 
   process_operation_definition_map(arel.related_action.choosen_method[1]);
  poo.plan := process_plan_map(arel.relating_action);
  poo.is_defined_in := 
    cartesian_coordinate_space_map(arel.related_action
      <-definition{action_property}
      ::representation{representation | 
                       name = 'reference system'}::context_of_items[1]);
END_MAP;

MAP process_operation_occurrence_relationship_map AS
  por : process_operation_occurrence_relationship;
FROM
  arel : action_relationship;
WHERE
  wr1: SIZEOF(arel.relating_action<-related_action{action_relationship | 
              name = 'process operation occurrence'}) > 0;
  wr2: SIZEOF(arel.related_action<-related_action{action_relationship | 
              name = 'process operation occurrence'}) > 0;
SELECT
  por.description := arel.description;
  por.relation_type := arel.name;
  por.related := process_operation_occurrence_map(arel.related_action);
  por.relating := process_operation_occurrence_map(arel.relating_action);
  por.cycle_time := 
    arel<-items{applied_time_interval_assignment | role.name='cycle time'}
        ::assigned_time_interval{time_interval_with_bounds |
                                 primary_bound.name = 'start of interval'}
        ::duration.value_component;
  por.waiting_time := 
    property_value_map(arel<-definition{action_property}
                           <-property{action_property_representation}
                          ::representation{representation}
                          ::items[1]);
END_MAP;

MAP process_property_association_map AS
  ppa : process_property_association;
PARTITION p_ap;
FROM
  ap : action_property;
SELECT
  ppa.describing_property_value := 
    property_value_representation_map(
      ap<-property{action_property_representation}
        ::representation[1]);
  ppa.described_element := process_property_select_map(ppa.definition);
  ppa.validity_context := 
    IF SIZEOF(ap<-items{applied_organization_assignment | 
                         name = 'validity context'}) > 0 THEN
      organization_map(ap<-items{applied_organization_assignment | 
                                  name = 'validity context'}
                          ::assigned_organization[1]) ;
   ELSE
     IF SIZEOF(ap<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}) > 0
     THEN
       product_class_map(ap<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}[1]);
     ELSE
       product_identification_map(ap<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_identification}[1]);
     END_IF;
   END_IF;
PARTITION p_res;
FROM
  rp : resource_property;
SELECT
  ppa.describing_property_value := 
    property_value_representation_map(
      rp<-property{resource_property_representation}
        ::representation[1]);
  ppa.described_element := process_property_select_map(ppa.definition);
  ppa.validity_context := 
    IF SIZEOF(rp<-items{applied_organization_assignment | 
                         name = 'validity context'}) > 0 THEN
      organization_map(rp<-items{applied_organization_assignment | 
                                  name = 'validity context'}
                          ::assigned_organization[1]) ;
   ELSE
     IF SIZEOF(rp<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}) > 0
     THEN
       product_class_map(rp<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_class}[1]);
     ELSE
       product_identification_map(rp<-related_property_definition
                    {property_definition_relationship | 
                     name = 'validity context'} 
                  ::relating_property_definition{property_definition |
                     name = 'context definition'}
                  ::definition{product_identification}[1]);
     END_IF;
   END_IF;
END_MAP;

MAP process_operation_resouce_assignment_map AS
  pora : process_operation_resource_assignment;
FROM
  rfar : requirement_for_action_resource;
SELECT
  pora.reason := rfar.description;
  pora.reference_tool := rfar.name = 'reference tool';
  pora.OPERATION := 
    product_operation_occurrence_map(rfar::operations{action}
      <-related_action{action_relationship |
                       name = 'process operation occurrence'}[1]);
END_MAP;

MAP process_operation_input_or_output_map AS
  poio : process_operation_input_or_output;
FROM
  ppa : process_product_association;
SELECT
  poio.description := ppa.description;
  poio.role := ppa.name;
  poio.concerned_shape := FOR EACH sasp IN ppa.process
                            <-process{process_property_association |
                                      name = 'concerned shape aspect'}
                            ::property_or_shape{shape_aspect};
                            RETURN (shape_element_map(saps));
  poio.element := 
    process_operation_input_or_output_select_map(ppa.defined_product);
END_MAP;

DEPENDENT_MAP descriptive_specification_map AS
  desp : descriptive_specification;
FROM
  deri : descriptive_representation_item;
SELECT
  desp.description := deri.description;
  desp.id := deri.name;
END_DEPENDENT_MAP;

MAP effectivity_map AS
  t_eff : effectivity;
FROM
  s_eff : effectivity;
WHERE
  wr1: (SIZEOF(['AUTOMOTIVE_DESIGN.DATED_EFFECTIVITY',
                'AUTOMOTIVE_DESIGN.TIME_INTERVAL_BASED_EFFECTIVITY']
               * TYPEOF(s_eff)) > 0) OR
       (SIZEOF(s_eff<-related_effectivity{effectivity_relationship | 
                                          name = 'inheritance'}) > 0);
SELECT
  t_eff.description := s_eff.description;
  t_eff.effectivity_context := s_eff.name;
  t_eff.id := s_eff.id;
  t_eff.version_id := s_eff<-items{applied_identification_assignment |
                                   role.name = 'version'}[1].assigned_id;
  t_eff.concerned_organization := 
    FOR EACH org IN (s_eff<-items{applied_organization_assignment | 
                                 role.name = 'concerned organization'}
                         ::assigned_organization);
      RETURN organization_map(org);
END_MAP;

MAP dated_effectivity_map AS
  t_eff : effectivity;
SUBTYPE OF (effectivity_map);
WHERE
  wr2: 'AUTOMOTIVE_DESIGN.DATED_EFFECTIVITY' IN TYPEOF(s_eff);
SELECT
  t_eff.start_definition := 
    IF 'AUTOMOTIVE_DESIGN.EVENT_OCCURRENCE' 
        IN TYPEOF(s_eff.effectivity_end_date) THEN
      event_reference_map(s_eff.effectivity_end_date);
    ELSE
      date_time_map(s_eff.effectivity_end_date);
    END_IF;
  t_eff.end_definition := 
    IF 'AUTOMOTIVE_DESIGN.EVENT_OCCURRENCE' 
        IN TYPEOF(s_eff.effectivity_end_date) THEN
      event_reference_map(s_eff.effectivity_end_date);
    ELSE
      date_time_map(s_eff.effectivity_end_date);
    END_IF;
END_MAP;

MAP time_interval_based_effectivity_map AS
  t_eff : effectivity;
SUBTYPE OF (effectivity_map);
WHERE
  wr2: 'AUTOMOTIVE_DESIGN.TIME_INTERVAL_BASED_EFFECTIVITY' 
       IN TYPEOF(s_eff);
SELECT
  t_eff.period := duration_map(s_eff.effectivity_period.duration);
  t_eff.start_definition := 
    IF 'AUTOMOTIVE_DESIGN.EVENT_OCCURRENCE' 
        IN TYPEOF(s_eff.effectivity_period.primary_bound) THEN
      event_reference_map(s_eff.effectivity_period.primary_bound);
    ELSE
      date_time_map(s_eff.effectivity_period.primary_bound);
    END_IF;
  t_eff.end_definition := 
    IF 'AUTOMOTIVE_DESIGN.EVENT_OCCURRENCE' 
        IN TYPEOF(s_eff.effectivity_period.primary_bound) THEN
      event_reference_map(s_eff.effectivity_period.secondary_bound);
    ELSE
      date_time_map(s_eff.effectivity_period.secondary_bound);
    END_IF;
END_MAP;

MAP manufacturing_configuration_map AS
  mc : manufacturing_configuration;
FROM
  ce : configuration_effectivity;
SELECT
  mc.concerned_organization := 
    organization_map(ce<-items{applied_organization_assignment | 
                               role.name = 'concerned organization'}
                       ::assigned_organization[1]);
  mc.configured_element := item_instance_map(
      ce::usage{assembly_component_usage}
        <-occurrence_usage{product_definition_occurrence_relationship}
        ::occurrence{product_definition}[1]);
  mc.is_solution_for := product_design_map(ce.configuration);
END_MAP;

MAP lot_configuration_map AS
  mc : lot_configuration;
SUBTYPE OF (manufacturing_configuration_map);
WHERE
  'AUTOMOTIVE_DESIGN.LOT_EFFECTIVITY' IN TYPEOF(ce);
SELECT
  mc.lot_id := ec.effectivity_lot_id;
  mc.lot_size := ec.lot_size.value_component;
END_MAP;

MAP serial_configuration_map AS
  mc : serial_configuration;
SUBTYPE OF (manufacturing_configuration_map);
WHERE
  'AUTOMOTIVE_DESIGN.SERIAL_NUMBERED_EFFECTIVITY' IN TYPEOF(ce);
SELECT
  mc.serial_end_number := ce.effectivity_end_id;
  mc.serial_start_number := ce.effectivity_start_id;  
END_MAP;

MAP dated_configuration_map AS
  mc : dated_configuration;
SUBTYPE OF (manufacturing_configuration_map);
WHERE
  'AUTOMOTIVE_DESIGN.DATED_EFFECTIVITY' IN TYPEOF(ce);
SELECT
  mc.end_date := date_time_map(ce.effectivity_end_date);
  mc.start_date := date_time_map(ce.effectivity_start_date);
END_MAP;

MAP event_reference_map AS
  ref : event_reference;
FROM
  occ : event_occurrence;
SELECT
  ref.description := occ.description; 
  ref.event_type := occ.name;
  ref.event_context := 
    general_organizational_data_select_map(
      occ<-assigned_event_occurrence{applied_event_occurrence_assignment |
                                     role.name = 'event context'}
         ::items[1]);
  ref.offset := IF 'AUTOMOTIVE_DESIGN.RELATIVE_EVENT_OCCURRENCE'
                   IN TYPEOF(occ) 
                THEN
                  duration_map(occ.offset);
                END_IF;
END_MAP;

DEPENDENT_MAP duration_map AS
  d : duration;
FROM
  tmu : time_measure_with_unit;
SELECT
  d.time := tmu.value_component;
  d.time_unit := get_unit_name(tmu.unit_component);
END_DEPENDENT_MAP;

MAP alias_identification_map AS
  aid : alias_identification;
FROM
  aia : applied_identification_assignment;
WHERE
  aia.role.name = 'alias';
SELECT
  aid.alias_id         := aia.assigned_id;
  aid.alias_scope      := organization_map(aia
                          <-items{applied_organization_assignment
                          | role.name = 'alias_scope'}[1]
                          .assigned_organization);
  aid.alias_version_id := aia<-items{applied_identification_assignment |
                                     role.name = 'version'}[1].assigned_id;
  aid.description      := aia<-items{applied_identification_assignment |
                          role.name = 'version'}[1].role.description; 
  aid.is_applied_to    := IF SIZEOF(aia.items[1]
                             <-products{product_related_product_category 
                                        | name = 'document'}) > 0
                          THEN
                            document_map(aia.items[1]);
                          ELSE
                            item_map(aia.items[1]); 
                          END_IF;
END_MAP;

MAP language_map AS
  t_lan : language;
FROM
  s_lan : language;
SELECT
  t_lan.country_code := s_lan.description;
  t_lan.language_code := s_lan.name;
END_MAP;

MAP string_with_language_map AS
  sl : string_with_language;
FROM
  ala : attribute_language_assignment;
SELECT
  sl.contents := ala.attribute_value;
  sl.language_specification := language_map(ala.assigned_class);
END_MAP;

MAP string_with_language_map AS
  mls : multi_language_string;
FROM
  mla : multi_language_attribute_assignment;
SELECT
  mla.primary_language_dependent_string := string_with_language_map(mla);
  mla.additional_language_dependent_string :=
    FOR EACH it IN mla<-items{multi_language_attribute_assignment |
                              role.name = 'alternate language'};
      RETURN (string_with_language_map(it));
END_MAP;


END_SCHEMA_MAP;