SCHEMA express_translater;
	USE FROM Express_toolsbox_functions;
	USE FROM express_dictionary_queries;
	USE FROM Platypus_dictionary_schema;
	USE FROM Platypus_expressions_schema;
	USE FROM Platypus_environment_schema;
	USE FROM Platypus_population_schema;
	USE FROM Platypus_statements_schema;
	USE FROM express_to_java_structure_translater;

	CONSTANT 
		signature : STRING := '//-------------------------------------------------------------------------------\n' 
		+ '//  This package was automatically generated from EXPRESS (ISO STEP 10303 part11)\n' 
		+ '//  by a java generator build with the meta CASE tool Platypus \n' 
		+ '//  (alain.plantec@univ-brest.fr)\n' 
		+ '// \n' 
		+ '//  Please, be aware that any hand-made updating of this file can be lost!!. \n' 
		+ '//-------------------------------------------------------------------------------\n\n';
		step_core_package : STRING := 'step.core';
		step_core_object : STRING := step_core_package + '.StepCoreObject';
		PathNameDelimiter : STRING := '/';
	END_CONSTANT;

	ENTITY resulting_file;
		path : STRING;
		contents : STRING;
	END_ENTITY;

	ENTITY translation_result 
		SUBTYPE OF ( entity_instance );
		files : LIST OF resulting_file;
	DERIVE
		current : resulting_file := files [ HIINDEX ( files ) ];
	END_ENTITY;

	ENTITY express_translater;
		result : translation_result;
	DERIVE
		current_result_file : resulting_file := result.current;
		current_result_file_contents : STRING := current_result_file.contents;
	END_ENTITY;

	PROCEDURE new_resulting_file ( VAR et : express_translater; path : STRING );
		INSERT ( et.result.files, resulting_file ( path, '' ), SIZEOF ( et.result.files ) );
		result ( et, signature );
	END_PROCEDURE;

	PROCEDURE translate_defined_type ( VAR et : express_translater; e : defined_type );
	END_PROCEDURE;

	PROCEDURE translate_schema_definition ( VAR et : express_translater; e : schema_definition );
		LOCAL 
			enum_types : LIST OF defined_type;
			jenum : java_enumeration_type;
		END_LOCAL;

		REPEAT noi := LOINDEX ( e.entities ) TO HIINDEX ( e.entities );
			ALIAS curr FOR e.entities [ noi];
				ALIAS jclass FOR java_class ( curr );
					new_resulting_file ( et, jclass.filepath );
					result ( et, jclass.class_spec );
					ALIAS jclassrw FOR java_class_step_io ( jclass );
						new_resulting_file ( et, jclassrw.filepath );
						result ( et, jclassrw.class_spec );
					END_ALIAS;
				END_ALIAS;
			END_ALIAS;
		END_REPEAT;
		enum_types :=
		 QUERY ( t <* e.types |
			 'PLATYPUS_DICTIONARY_SCHEMA.ENUMERATION_TYPE' IN TYPEOF ( t.domain ) );

		REPEAT noi := LOINDEX ( enum_types ) TO HIINDEX ( enum_types );
			ALIAS curr FOR enum_types [ noi];
				jenum := java_enumeration_type ( ) || curr.domain;
				new_resulting_file ( et, jenum.filepath );
				result ( et, jenum.enum_spec );
			END_ALIAS;
		END_REPEAT;
	END_PROCEDURE;

	PROCEDURE translate_schema_instance ( VAR et : express_translater; e : schema_instance );

		REPEAT noi := LOINDEX ( e.schemata ) TO HIINDEX ( e.schemata );
			ALIAS curr_schema FOR e.schemata [ noi];
				translate_schema_definition ( et, curr_schema );
			END_ALIAS;
		END_REPEAT;

		ALIAS jpkg FOR java_package ( e );
			new_resulting_file ( et, jpkg.visitor_filepath );
			result ( et, jpkg.visitor_spec );
			new_resulting_file ( et, jpkg.repository_filepath );
			result ( et, jpkg.repository_spec );
			new_resulting_file ( et, jpkg.repository_parse_filepath );
			result ( et, jpkg.repository_parse_spec );
		END_ALIAS;
	END_PROCEDURE;

	PROCEDURE translatesFromMetaDataFile ( filePath : STRING );
		LOCAL 
			translater : express_translater :=
			 express_translater ( translation_result ( [ ] ) ||
				 entity_instance ( ) ) ||
			 entity_instance ( );
			translater_list : LIST OF express_translater;
			instances : LIST OF application_instance;
			schemaInstances : LIST OF schema_instance;
			fullText : STRING := '';
		END_LOCAL;
		ReadStepFile ( filePath );
		instances := setToList ( allModelInstances );
		schemaInstances :=
		 QUERY ( inst <* instances |
			 ( 'PLATYPUS_ENVIRONMENT_SCHEMA.SCHEMA_INSTANCE' IN TYPEOF ( inst ) ) );

		REPEAT no := LOINDEX ( schemaInstances ) TO HIINDEX ( schemaInstances );
			translate_schema_instance ( translater, schemaInstances [ no] );
		END_REPEAT;

		REPEAT no := LOINDEX ( translater.result.files ) TO HIINDEX ( translater.result.files );
			WriteFile ( translater.result.files [ no].path, translater.result.files [ no].contents );
			fullText := fullText + translater.result.files [ no].path + '\n' 
			+ translater.result.files [ no].contents + '\n--------------------------\n';
		END_REPEAT;
		(*# <Platypus>(Workspace new contents: self fullText asClearText) openLabel: 'Translation 2 ADA result'. #*)
		(*# <pharo> (Workspace new contents: (PltStringLiteral val: self fullText) asClearText) 
				openLabel: 'Translation 2 ADA result'. 		#*);
	END_PROCEDURE;

	PROCEDURE translate;

		IF ( EXISTS ( askForExpressDictionaryMetaData ( 'meta.step' ) ) ) THEN
			translatesFromMetaDataFile ( 'meta.step' );
		END_IF;
	END_PROCEDURE;

	PROCEDURE result ( VAR et : express_translater; added : STRING );
		et.current_result_file.contents := et.current_result_file.contents + added;
	END_PROCEDURE;
END_SCHEMA;

SCHEMA express_to_java_structure_translater;
	USE FROM platypus_dictionary_schema;
	USE FROM platypus_environment_schema;
	USE FROM express_toolsbox_functions;
	USE FROM express_dictionary_queries;
	USE FROM express_translater;

	ENTITY basic_type_getter 
		SUBTYPE OF ( entity_instance );
	DERIVE
		accept_string_type : entity_instance := ( java_string_type ( ) || SELF\string_type );
		accept_binary_type : entity_instance := ( java_binary_type ( ) || SELF\binary_type );
		accept_integer_type : entity_instance := ( java_integer_type ( ) || SELF\integer_type );
		accept_real_type : entity_instance := ( java_real_type ( ) || SELF\real_type );
		accept_boolean_type : entity_instance := ( java_boolean_type ( ) || SELF\boolean_type );
		accept_logical_type : entity_instance := ( java_logical_type ( ) || SELF\logical_type );
		accept_named_type_reference : entity_instance := ( basic_domain ( SELF.ref ) );
		accept_defined_type_reference : entity_instance := ( basic_domain ( SELF.ref ) );
		accept_entity_definition_reference : entity_instance := ( basic_domain ( SELF.ref ) );
		accept_defined_type : entity_instance := basic_domain ( SELF.domain );
		accept_entity_definition : entity_instance := java_class ( SELF );
		accept_list_type : entity_instance := ( java_list_type ( ) || SELF\list_type );
		accept_array_type : entity_instance := ( java_array_type ( ) || SELF\array_type );
		accept_set_type : entity_instance := ( java_set_type ( ) || SELF\set_type );
		accept_bag_type : entity_instance := ( java_bag_type ( ) || SELF\bag_type );
		accept_select_type : entity_instance := ( java_select_type ( ) || SELF\select_type );
		accept_enumeration_type : entity_instance :=
		 ( java_enumeration_type ( ) ||
			 SELF\enumeration_type );
	END_ENTITY;

	FUNCTION basic_domain ( d : dictionary_instance ) : entity_instance;
		RETURN ( ( d || basic_type_getter ( ) ).accepted );
	END_FUNCTION;

	ENTITY java_string_type 
		SUBTYPE OF ( string_type );
	DERIVE
		type_spec : STRING := 'String';
		type_init : STRING := '""';
	END_ENTITY;

	ENTITY java_logical_type 
		SUBTYPE OF ( logical_type );
	DERIVE
		type_spec : STRING := 'Boolean';
		type_init : STRING := 'false';
	END_ENTITY;

	ENTITY java_binary_type 
		SUBTYPE OF ( binary_type );
	DERIVE
		type_spec : STRING := 'String';
		type_init : STRING := '""';
	END_ENTITY;

	ENTITY java_boolean_type 
		SUBTYPE OF ( boolean_type );
	DERIVE
		type_spec : STRING := 'Boolean';
		type_init : STRING := 'false';
	END_ENTITY;

	ENTITY java_real_type 
		SUBTYPE OF ( real_type );
	DERIVE
		type_spec : STRING := 'Double';
		type_init : STRING := '0.0';
	END_ENTITY;

	ENTITY java_integer_type 
		SUBTYPE OF ( integer_type );
	DERIVE
		type_spec : STRING := 'Integer';
		type_init : STRING := '0';
	END_ENTITY;

	ENTITY java_named_type_reference 
		SUBTYPE OF ( named_type_reference );
	DERIVE
		type_spec : STRING := SELF.handled.name;
		type_init : STRING := 'null';
	END_ENTITY;

	FUNCTION java_attribute_set_accessor_spec ( jattr : java_attribute ) : STRING;
		LOCAL 
			domain : dictionary_instance := jattr.domain;
			code : STRING;
		END_LOCAL;

		IF ( 'PLATYPUS_DICTIONARY_SCHEMA.AGGREGATION_TYPE' IN TYPEOF ( domain ) ) THEN
			ALIAS elem_type_spec FOR basic_domain ( domain.element_type ).type_spec;
				code :=
				 '  public void ' +
				 jattr.set_accessor_name +
				 '(ArrayList<' +
				 elem_type_spec +
				 '> _v) {\n' 
				+ '    if (_v == null) {\n' 
				+ '      ' + jattr.var_name + ' = null;\n' 
				+ '    } else {\n' 
				+ '      if (' + jattr.var_name + ' == null) {\n' 
				+ '        ' + jattr.var_name + ' = ' + domain.type_init + ';\n' 
				+ '      } else {\n' 
				+ '        ' + jattr.var_name + '.clear();\n' 
				+ '      }\n' 
				+ '      ' + jattr.var_name + '.addAll(_v);\n' 
				+ '    }\n' 
				+ '  }\n' 
				+ '  public void ' + capitalize ( jattr.name,
					 false ) + 'Add (' + elem_type_spec + ' _elem)  {\n' 
				+ '    if (' + jattr.var_name + ' == null) {\n' 
				+ '      ' + jattr.var_name + ' = ' + domain.type_init + ';\n' 
				+ '    }\n' 
				+ '    ' + jattr.var_name + '.add(_elem);\n' 
				+ '  }\n' 
				+ '  public boolean ' + capitalize ( jattr.name,
					 false ) + 'Remove(' + elem_type_spec + ' _elem)  {\n' 
				+ '    if (' + jattr.var_name + ' != null) {\n' 
				+ '      return ' + jattr.var_name + '.remove(_elem);\n' 
				+ '    }\n' 
				+ '    return false;\n' 
				+ '  }\n' 
				+ '  public boolean ' + capitalize ( jattr.name,
					 false ) + 'RemoveAll(ArrayList<' + elem_type_spec + '> _v)  {\n' 
				+ '    if (' + jattr.var_name + ' != null) {\n' 
				+ '      return ' + jattr.var_name + '.removeAll(_v);\n' 
				+ '    }\n' 
				+ '    return false;\n' 
				+ '  }\n' 
				+ '  public void ' + capitalize ( jattr.name,
					 false ) + 'AddAll(ArrayList<' + elem_type_spec + '> _v)  {\n' 
				+ '    if (' + jattr.var_name + ' == null) {\n' 
				+ '      ' + jattr.var_name + ' = ' + domain.type_init + ';\n' 
				+ '    }\n' 
				+ '    ' + jattr.var_name + '.addAll(_v);\n' 
				+ '  }\n';
				IF ( 'PLATYPUS_DICTIONARY_SCHEMA.ARRAY_TYPE' IN TYPEOF ( domain ) ) OR
					 ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN
						 TYPEOF ( domain ) ) THEN
					code :=
					 code + '  public ' + elem_type_spec + '  ' + capitalize ( jattr.name,
						 false ) + 'Set (int _pos, ' + elem_type_spec + ' _elem)  {\n' 
					+ '    return ' + jattr.var_name + '.set(_pos, _elem);\n' 
					+ '  }\n';
				END_IF;
			END_ALIAS;
		ELSE
			code :=
			 '  public void ' +
			 jattr.set_accessor_name +
			 ' ( ' +
			 domain.type_spec +
			 ' _v ) { ' +
			 jattr.var_name +
			 ' = _v; }\n';
		END_IF;
		RETURN ( code );
	END_FUNCTION;

	ENTITY java_array_type 
		SUBTYPE OF ( array_type );
	DERIVE
		type_spec : STRING := 'ArrayList<' + basic_domain ( SELF.element_type ).type_spec + '>';
		type_init : STRING := 'new ' + type_spec + '()';
	END_ENTITY;

	ENTITY java_list_type 
		SUBTYPE OF ( list_type );
	DERIVE
		type_spec : STRING := 'ArrayList<' + basic_domain ( SELF.element_type ).type_spec + '>';
		type_init : STRING := 'new ' + type_spec + '()';
	END_ENTITY;

	ENTITY java_set_type 
		SUBTYPE OF ( set_type );
	DERIVE
		type_spec : STRING := 'HashSet<' + basic_domain ( SELF.element_type ).type_spec + '>';
		type_init : STRING := 'new ' + type_spec + '()';
	END_ENTITY;

	ENTITY java_bag_type 
		SUBTYPE OF ( bag_type );
	DERIVE
		type_spec : STRING := 'ArrayList<' + basic_domain ( SELF.element_type ).type_spec + '>';
		type_init : STRING := 'new ' + type_spec + '()';
	END_ENTITY;

	ENTITY java_attribute 
		SUBTYPE OF ( entity_instance );
		attr : attribute;
	DERIVE
		jclass : java_class := java_class ( attr.owner );
		name : STRING := SELF.attr.name;
		var_name : STRING := SELF.name + '_';
		get_accessor_name : STRING := 'get' + capitalize ( SELF.name, true );
		attribute_spec : STRING := '';
		attribute_init : STRING := '';
		set_accessor_spec : STRING := '';
		get_accessor_spec : STRING := '';
		domain : dictionary_instance := basic_domain ( SELF.attr.domain );
		redeclaring : attribute := SELF.attr.redeclaring.ref;
		replace_reference_spec : STRING := '';
		generic_value_convertion_spec : STRING := '';
	END_ENTITY;

	ENTITY java_explicit_attribute 
		SUBTYPE OF ( java_attribute );
		SELF\java_attribute.attr : explicit_attribute;
	DERIVE
		set_accessor_name : STRING := 'set' + capitalize ( name, true );
		SELF\java_attribute.set_accessor_spec : STRING :=
		 java_attribute_set_accessor_spec ( SELF );
		SELF\java_attribute.get_accessor_spec : STRING :=
		 java_attribute_get_accessor_spec ( SELF );
		SELF\java_attribute.attribute_spec : STRING :=
		 '  private ' + domain.type_spec + ' ' + var_name + ';\n';
		SELF\java_attribute.attribute_init : STRING := java_explicit_attribute_init ( SELF );
		SELF\java_attribute.replace_reference_spec : STRING :=
		 ( ( domain_code_getter ( domain_code_getter_data ( ) ||
					 domain_code_getter_replace_spec_data ( attr.owner,
						 get_accessor_name,
						 set_accessor_name,
						 ?,
						 ?,
						 'i' ) ) ||
				 attr.domain ).accepted ).replace_spec;
		SELF\java_attribute.generic_value_convertion_spec : STRING :=
		 ( ( domain_code_getter ( domain_code_getter_data ( ) ||
					 domain_code_getter_convertion_spec_data ( SELF ) ) ||
				 attr.domain ).accepted ).generic_value_convertion_spec;
	END_ENTITY;

	FUNCTION java_explicit_attribute_init ( jattr : java_explicit_attribute ) : STRING;
		LOCAL 
			attr : explicit_attribute := jattr.attr;
		END_LOCAL;

		IF ( NOT ( attr.optional_flag ) ) THEN
			RETURN ( jattr.domain.type_init );
		END_IF;
		RETURN ( 'null' );
	END_FUNCTION;

	ENTITY java_derived_attribute 
		SUBTYPE OF ( java_attribute );
		SELF\java_attribute.attr : derived_attribute;
	DERIVE
		SELF\java_attribute.get_accessor_spec : STRING :=
		 '  public ' +
		 domain.type_spec +
		 ' ' +
		 get_accessor_name +
		 '() { throw new Exception("Not yet generated") }\n';
	END_ENTITY;

	ENTITY java_inverse_attribute 
		SUBTYPE OF ( java_attribute );
		SELF\java_attribute.attr : inverse_attribute;
	DERIVE
		SELF\java_attribute.get_accessor_spec : STRING :=
		 java_inverse_attribute_get_accessor_spec ( SELF );
		inverted_jattr : java_explicit_attribute :=
		 java_attribute ( attr.inverted_attr.ref ) ||
		 java_explicit_attribute ( attr.inverted_attr.ref );
		inverted_jclass : java_class := java_class ( attr.inverted_attr.ref.owner );
		inverted_attr_owner_class_name : STRING := inverted_jclass.name;
		inverted_attr_get_accessor_name : STRING := inverted_jattr.get_accessor_name;
	END_ENTITY;

	ENTITY java_class 
		SUBTYPE OF ( dictionary_instance );
		ent : entity_definition;
	DERIVE
		name : STRING := ent.name;
		type_spec : STRING := name;
		type_init : STRING := 'null';
		filename : STRING := name + '.java';
		filepath : STRING := package.name + PathNameDelimiter + filename;
		package : java_package := java_package ( schema_instance_of ( ent ) );
		extends : STRING := NVL ( ' extends ' + java_class_extends ( SELF ), '' );
		implements : STRING := '';
		accept : STRING :=
		 '  public void accept(' +
		 package.visitor_name +
		 ' visitor ) { visitor.accept((' +
		 name +
		 ') this); }\n';
		readerWriter : STRING :=
		 '  public ' +
		 step_core_package +
		 '.' +
		 package.step_rw_name +
		 ' readerWriter() { return new ' +
		 java_class_step_io ( SELF ).name +
		 '(); }\n';
		class_spec : STRING := java_class_spec ( SELF );
		attributes : LIST OF java_attribute := java_class_attributes ( SELF, ?, false, false );
		all_attributes : LIST OF java_attribute := java_class_attributes ( SELF, ?, false, true );
		explicit_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 'EXPLICIT_ATTRIBUTE',
			 false,
			 false );
		inverse_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 'INVERSE_ATTRIBUTE',
			 false,
			 false );
		all_explicit_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 'EXPLICIT_ATTRIBUTE',
			 false,
			 true );
		inherited_attributes : LIST OF java_attribute := java_class_attributes ( SELF, ?, true, false );
		all_inherited_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 ?,
			 true,
			 true );
		inherited_explicit_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 'EXPLICIT_ATTRIBUTE',
			 true,
			 false );
		all_inherited_explicit_attributes : LIST OF java_attribute :=
		 java_class_attributes ( SELF,
			 'EXPLICIT_ATTRIBUTE',
			 true,
			 true );
	END_ENTITY;

	ENTITY java_class_step_io;
		jclass : java_class;
	DERIVE
		name : STRING := jclass.name + 'StepRW';
		filename : STRING := name + '.java';
		filepath : STRING := jclass.package.name + PathNameDelimiter + filename;
		extends : STRING := 'extends ' + java_class_step_io_extends ( SELF );
		class_spec : STRING := java_class_step_rw_spec ( SELF );
	END_ENTITY;

	FUNCTION java_class_step_io_extends ( step_io : java_class_step_io ) : STRING;
		LOCAL 
			jclass : java_class := step_io.jclass;
			result : STRING;
		END_LOCAL;

		IF ( SIZEOF ( jclass.ent.supertypes ) > 0 ) THEN
			result := java_class_step_io ( java_class ( jclass.ent.supertypes [ 1 ].ref ) ).name;
		ELSE
			result := step_core_package + '.StepCoreObjectReaderWriter';
		END_IF;
		RETURN ( result );
	END_FUNCTION;

	ENTITY java_attribute_getter 
		SUBTYPE OF ( entity_instance );
	DERIVE
		accept_explicit_attribute : entity_instance :=
		 ( java_explicit_attribute ( SELF\explicit_attribute ) ||
			 java_attribute ( SELF\explicit_attribute ) );
		accept_derived_attribute : entity_instance :=
		 ( java_attribute ( SELF\derived_attribute ) ||
			 java_derived_attribute ( SELF\derived_attribute ) );
		accept_inverse_attribute : entity_instance :=
		 ( java_attribute ( SELF\inverse_attribute ) ||
			 java_inverse_attribute ( SELF\inverse_attribute ) );
	END_ENTITY;

	FUNCTION java_class_attributes ( jclass : java_class;
			 attr_kind : STRING;
			 with_inherited : BOOLEAN;
			 with_redeclaring : BOOLEAN ) : LIST OF java_attribute;
		LOCAL 
			res : LIST OF java_attribute := [ ];
			attributes : LIST OF attribute :=
			 query_attributes ( jclass.ent,
				 attr_kind,
				 with_inherited,
				 with_redeclaring );
		END_LOCAL;

		REPEAT no := LOINDEX ( attributes ) TO HIINDEX ( attributes );
			res := res + ( ( java_attribute_getter ( ) || attributes [ no] ).accepted );
		END_REPEAT;
		RETURN ( res );
	END_FUNCTION;

	FUNCTION java_class_extends ( jclass : java_class ) : STRING;
		LOCAL 
			result : STRING := ?;
		END_LOCAL;

		IF ( SIZEOF ( jclass.ent.supertypes ) > 0 ) THEN
			result := java_class ( jclass.ent.supertypes [ 1 ].ref ).name;
		ELSE
			result := step_core_package + '.StepCoreObject';
		END_IF;
		RETURN ( result );
	END_FUNCTION;

	FUNCTION java_class_spec ( jclass : java_class ) : STRING;
		LOCAL 
			explicites : LIST OF java_attribute := jclass.explicit_attributes;
			Inverses : LIST OF java_attribute := jclass.inverse_attributes;
			code : STRING := '';
		END_LOCAL;
		code := code + 'package ' + jclass.package.name + ';\n' 
		+ 'import java.util.*;\nimport step.core.*;\n \n' 
		+ 'public class ' + jclass.name + jclass.extends + jclass.implements + ' {\n \n' 
		+ '  private static String EntityName = "' + upperize ( jclass.name ) + '";\n';

		REPEAT no := LOINDEX ( explicites ) TO HIINDEX ( explicites );
			ALIAS jattr FOR explicites [ no];
				code := code + jattr.attribute_spec;
			END_ALIAS;
		END_REPEAT;
		code := code + '\n' 
		+ '  public static String EntityName() { return EntityName; }\n' 
		+ '  public String entityName() { return EntityName(); }\n' 
		+ '  public boolean isInstanceOf(String entName) { return entName.equals(EntityName); }\n' 
		+
		 '  public boolean isKindOf(String entName) { return entName.equals(EntityName) ? true : super.isKindOf(entName); }\n\n' 

		+ '  public void initializeExplicitAttributes() {\n' 
		+ '    super.initializeExplicitAttributes();\n';

		REPEAT no := LOINDEX ( explicites ) TO HIINDEX ( explicites );
			ALIAS jattr FOR explicites [ no];
				code := code + '    ' + jattr.var_name + ' = ' + jattr.attribute_init + ';\n';
			END_ALIAS;
		END_REPEAT;
		code := code + '  }\n\n' 

		+ '  public ' + jclass.name + ' () {\n' 
		+ '    initializeExplicitAttributes();\n' 
		+ '  }\n' 
		+ '  public ' + jclass.name + ' (step.core.StepCoreRepository _repo) {\n' 
		+ '    super(_repo);\n' 
		+ '    initializeExplicitAttributes();\n' 
		+ '  }\n \n';

		REPEAT no := LOINDEX ( explicites ) TO HIINDEX ( explicites );
			ALIAS jattr FOR explicites [ no];
				code := code + jattr.set_accessor_spec + jattr.get_accessor_spec;
			END_ALIAS;
		END_REPEAT;

		REPEAT no := LOINDEX ( inverses ) TO HIINDEX ( inverses );
			ALIAS jattr FOR inverses [ no];
				code := code + jattr.get_accessor_spec;
			END_ALIAS;
		END_REPEAT;
		code := code + jclass.accept + jclass.readerWriter + '\n';
		code :=
		 code +
		 '  public boolean replaceReferenceWith(StepCoreObject oldObj, StepCoreObject newObj) {\n' 
		+ '    boolean done = false;\n';

		REPEAT no := LOINDEX ( explicites ) TO HIINDEX ( explicites );
			ALIAS jattr FOR explicites [ no];
				code := code + jattr.replace_reference_spec;
			END_ALIAS;
		END_REPEAT;
		code := code + '    if (super.replaceReferenceWith(oldObj, newObj)) {\n' 
		+ '      done = true;\n' 
		+ '    }\n' 
		+ '    return done;\n' 
		+ '  }\n' 
		+ '}\n\n';
		RETURN ( code );
	END_FUNCTION;

	FUNCTION java_class_step_rw_spec ( jclassio : java_class_step_io ) : STRING;
		LOCAL 
			jclass : java_class := jclassio.jclass;
			jattributes : LIST OF java_attribute := jclass.inherited_explicit_attributes;
			jall_attributes : LIST OF java_attribute := jclass.all_inherited_attributes;
			code : STRING := '';
			currno : INTEGER;
		END_LOCAL;
		code := code + 'package ' + jclass.package.name + ';\n' 
		+ 'import java.util.*;\n' 
		+ 'import java.io.*;\n' 
		+ 'import ' + step_core_package + '.*;\n \n' 
		+ 'class ' + jclassio.name + ' ' + jclassio.extends + ' {\n \n' 
		+ '  public ' + step_core_object + ' coreObject() {\n' 
		+ '    return new ' + jclass.name + '();\n' 
		+ '  }\n\n' 

		+ '  public String entityName() {\n' 
		+ '    return ' + jclass.name + '.EntityName();\n' 
		+ '  }\n\n';
		currno := - 1;

		REPEAT no := LOINDEX ( jall_attributes ) TO HIINDEX ( jall_attributes );
			ALIAS curr FOR jall_attributes [ no];
				IF ( 'EXPRESS_TO_JAVA_STRUCTURE_TRANSLATER.JAVA_EXPLICIT_ATTRIBUTE' IN
						 TYPEOF ( curr ) ) THEN
					currno := currno + 1;
					IF ( ( jclass.ent.name = curr.attr.owner.name ) AND
							 ( NOT EXISTS ( attribute_redeclared_by ( jclass.ent,
										 no ) ) ) ) THEN
						code :=
						 code +
						 '  public ' +
						 curr.domain.type_spec +
						 ' ' +
						 curr.get_accessor_name +
						 '(StepCoreRepository repo,  StepInternalRepresentation si) throws Exception {\n' 
						+ '    ArrayList<StepValue> values = si.getValues();\n' 
						+ '    StepValue stepVal = values.get(' + FORMAT ( currno,
							 'I' ) + ');\n' 
						+ '    ' + curr.generic_value_convertion_spec + '\n' 
						+ '  }\n';
					END_IF;
				END_IF;
			END_ALIAS;
		END_REPEAT;
		code :=
		 code +
		 '\n  public void initializeCoreObject(StepCoreRepository repo, ' +
		 step_core_object +
		 '  coreObj, StepGenericInstance si) throws Exception {\n';

		IF ( SIZEOF ( jattributes ) > 0 ) THEN
			code := code + '    super.initializeCoreObject(repo, coreObj, si);\n' 
			+ '    ' + jclass.name + ' obj = (' + jclass.name + ') coreObj;\n';
			REPEAT no := LOINDEX ( jall_attributes ) TO HIINDEX ( jall_attributes );
				ALIAS curr FOR jall_attributes [ no];
					IF ( 'EXPRESS_TO_JAVA_STRUCTURE_TRANSLATER.JAVA_EXPLICIT_ATTRIBUTE' IN
							 TYPEOF ( curr ) ) THEN
						currno := currno + 1;
						IF ( ( jclass.ent.name = curr.attr.owner.name ) AND
								 ( NOT EXISTS ( attribute_redeclared_by ( jclass.ent,
											 no ) ) ) ) THEN
							code :=
							 code +
							 '    obj.' +
							 curr.set_accessor_name +
							 '(' +
							 curr.get_accessor_name +
							 '(repo, (StepInternalRepresentation) si));\n';
						END_IF;
					END_IF;
				END_ALIAS;
			END_REPEAT;
		END_IF;
		code := code + '  }\n' 
		+
		 '\n  public StepGenericInstance genericInstance(StepCoreRepository crepo, ' +
		 step_core_object +
		 ' coreObj) throws Exception {\n' 
		+
		 '   StepInternalRepresentation si = (StepInternalRepresentation) super.genericInstance(crepo, coreObj);\n' 
		+ '    ' + jclass.name + ' obj = (' + jclass.name + ') coreObj;\n';

		REPEAT no := LOINDEX ( jall_attributes ) TO HIINDEX ( jall_attributes );
			ALIAS curr FOR jall_attributes [ no];
				IF ( ( jclass.ent.name = curr.attr.owner.name ) AND
						 ( 'EXPRESS_TO_JAVA_STRUCTURE_TRANSLATER.JAVA_EXPLICIT_ATTRIBUTE' IN
							 TYPEOF ( curr ) ) ) THEN
					IF ( EXISTS ( attribute_redeclared_by ( jclass.ent, no ) ) ) THEN
						code := code + '    si.add(new StepRedefinedValue());\n';
					ELSE
						code :=
						 code +
						 '    si.add(stepValueOf(crepo, obj.' +
						 curr.get_accessor_name +
						 '()));\n';
					END_IF;
				END_IF;
			END_ALIAS;
		END_REPEAT;
		code := code + '    return  si;\n' 
		+ '  }\n' 
		+ '}\n';
		RETURN ( code );
	END_FUNCTION;

	ENTITY java_package;
		schi : schema_instance;
	DERIVE
		name : STRING := schi.name;
		visitor_name : STRING := name + '_AbstractVisitor';
		visitor_filename : STRING := visitor_name + '.java';
		visitor_filepath : STRING := name + PathNameDelimiter + visitor_filename;
		visitor_spec : STRING := java_package_visitor_spec ( SELF );
		step_rw_name : STRING := 'StepCoreObjectReaderWriter';
		repository_name : STRING := name + '_StepRepository';
		repository_filename : STRING := repository_name + '.java';
		repository_filepath : STRING := name + PathNameDelimiter + repository_filename;
		repository_spec : STRING := java_package_repository_spec ( SELF );
		repository_parse_name : STRING := name + '_Parse';
		repository_parse_filename : STRING := repository_parse_name + '.java';
		repository_parse_filepath : STRING :=
		 name + PathNameDelimiter + repository_parse_filename;
		repository_parse_spec : STRING := java_package_parse_spec ( SELF );
	END_ENTITY;

	FUNCTION java_package_visitor_spec ( jpkg : java_package ) : STRING;
		LOCAL 
			code : STRING := '';
			entities : LIST OF entity_definition := [ ];
		END_LOCAL;

		REPEAT noi := LOINDEX ( jpkg.schi.schemata ) TO HIINDEX ( jpkg.schi.schemata );
			ALIAS curr_schema FOR jpkg.schi.schemata [ noi];
				entities := entities + curr_schema.entities;
			END_ALIAS;
		END_REPEAT;
		code := code + 'package ' + jpkg.name + ';\n\npublic class ' + jpkg.visitor_name + ' {\n';

		REPEAT no := LOINDEX ( entities ) TO HIINDEX ( entities );
			ALIAS jclass FOR java_class ( entities [ no] );
				code := code + '  public void accept(' + jclass.name + ' e) { }\n';
			END_ALIAS;
		END_REPEAT;
		code := code + '}\n';
		RETURN ( code );
	END_FUNCTION;

	FUNCTION java_enumeration_spec ( e : java_enumeration_type ) : STRING;
		LOCAL 
			s : STRING := 'package ' + e.package.name + ';\n\npublic enum ' + e.name + ' {\n';
		END_LOCAL;

		REPEAT no := LOINDEX ( e.elements ) TO HIINDEX ( e.elements );
			s := s + '  ' + e.elements [ no];
			IF ( no < HIINDEX ( e.elements ) ) THEN
				s := s + ',\n';
			ELSE
				s := s + ';\n';
			END_IF;
		END_REPEAT;
		s := s + '  public static ' + e.name + ' fromString(String rep) throws Exception {\n';
		s := s + '    if (rep == null) return  (null);\n';

		REPEAT no := LOINDEX ( e.elements ) TO HIINDEX ( e.elements );
			s :=
			 s + '    if (rep.equals("' + e.elements [ no] + '")) return  (' + e.elements [ no] + ');\n';
		END_REPEAT;
		s :=
		 s +
		 '    throw new Exception("invalid ' +
		 e.name +
		 ' enum string representation (" + rep + ")");\n' 
		+ '  }\n}\n';
		RETURN ( s );
	END_FUNCTION;

	ENTITY java_enumeration_type 
		SUBTYPE OF ( enumeration_type );
	DERIVE
		name : STRING := owner.name;
		package : java_package := java_package ( schema_instance_of ( owner ) );
		filename : STRING := name + '.java';
		filepath : STRING := package.name + PathNameDelimiter + filename;
		type_spec : STRING := name;
		type_init : STRING := name + '.' + elements [ LOINDEX ( elements ) ];
		enum_spec : STRING := java_enumeration_spec ( SELF );
	END_ENTITY;

	ENTITY java_select_type 
		SUBTYPE OF ( select_type );
	DERIVE
		type_spec : STRING := 'Object';
		type_init : STRING := 'null';
	END_ENTITY;

	FUNCTION java_package_repository_spec ( jpkg : java_package ) : STRING;
		LOCAL 
			code : STRING := '';
			entities : LIST OF entity_definition := [ ];
		END_LOCAL;

		REPEAT noi := LOINDEX ( jpkg.schi.schemata ) TO HIINDEX ( jpkg.schi.schemata );
			ALIAS curr_schema FOR jpkg.schi.schemata [ noi];
				entities := entities + curr_schema.entities;
			END_ALIAS;
		END_REPEAT;
		code :=
		 code +
		 'package ' +
		 jpkg.name +
		 ';\n\npublic class ' +
		 jpkg.repository_name +
		 ' extends ' +
		 step_core_package +
		 '.StepCoreRepository {\n';
		code := code + '  public ' + jpkg.repository_name + ' () {\n';

		REPEAT no := LOINDEX ( entities ) TO HIINDEX ( entities );
			ALIAS jclass FOR java_class ( entities [ no] );
				code :=
				 code +
				 '    rwByEntityNameIndex.put("' +
				 upperize ( jclass.ent.name ) +
				 '", new ' +
				 java_class_step_io ( jclass ).name +
				 '());\n';
			END_ALIAS;
		END_REPEAT;
		code := code + '  }\n\n' 

		+ '}\n';
		RETURN ( code );
	END_FUNCTION;

	FUNCTION java_package_parse_spec ( jpkg : java_package ) : STRING;
		LOCAL 
			code : STRING := '';
		END_LOCAL;
		code := 'package ' + jpkg.name + ';\n' 
		+ 'import java.io.*;\n \n' 
		+ 'public class ' + jpkg.repository_parse_name + ' {\n' 
		+ '  public static void main (String args[]) throws Exception {\n' 
		+ '    ' + jpkg.repository_name + ' repo = new ' + jpkg.repository_name + ' ();\n \n' 
		+ '    if (args.length == 1) { \n' 
		+ '      try {\n' 
		+ '        repo.parseFileNamed(args[0]);\n' 
		+ '        repo.write(new OutputStreamWriter(System.out));\n' 
		+ '      } catch (Exception e) {\n' 
		+ '         throw (e);\n' 
		+ '      } finally {\n' 
		+ '      }\n' 
		+ '    } else {\n' 
		+ '      System.out.println("need one step file path arg");\n' 
		+ '    }\n' 
		+ '  }\n' 
		+ '}\n';
		RETURN ( code );
	END_FUNCTION;

	FUNCTION java_attribute_get_accessor_spec ( jattr : java_attribute ) : STRING;
		LOCAL 
			domain : dictionary_instance := jattr.domain;
			code : STRING;
		END_LOCAL;

		IF ( 'PLATYPUS_DICTIONARY_SCHEMA.AGGREGATION_TYPE' IN TYPEOF ( domain ) ) THEN
			ALIAS elem_type_spec FOR basic_domain ( domain.element_type ).type_spec;
				code :=
				 '  public ' +
				 jattr.domain.type_spec +
				 ' ' +
				 jattr.get_accessor_name +
				 '() {\n' 
				+ '    return ' + jattr.var_name + '; \n' 
				+ '  }\n' 
				+ '  public int ' + capitalize ( jattr.name, false ) + 'Size ()  {\n' 
				+
				 '    return ' +
				 jattr.var_name +
				 ' == null ?  0 : ' +
				 jattr.var_name +
				 '.size();\n' 
				+ '  }\n';
				IF ( 'PLATYPUS_DICTIONARY_SCHEMA.ARRAY_TYPE' IN TYPEOF ( domain ) ) OR
					 ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN
						 TYPEOF ( domain ) ) THEN
					code :=
					 code + '  public ' + elem_type_spec + '  ' + capitalize ( jattr.name,
						 false ) + 'Get (int _pos)  {\n' 
					+ '    return ' + jattr.var_name + '.get(_pos);\n' 
					+ '  }\n';
				END_IF;
			END_ALIAS;
		ELSE
			code :=
			 '  public ' +
			 jattr.domain.type_spec +
			 ' ' +
			 jattr.get_accessor_name +
			 '() { return ' +
			 jattr.var_name +
			 '; }\n';
		END_IF;
		RETURN ( code );
	END_FUNCTION;

	FUNCTION java_inverse_attribute_get_accessor_spec ( jattr : java_inverse_attribute ) : STRING;
		LOCAL 
			ret_domain : STRING;
			s : STRING;
		END_LOCAL;

		IF ( EXISTS ( jattr.attr.min_cardinality ) ) THEN
			ret_domain := 'ArrayList<' + jattr.domain.type_spec + '>';
		ELSE
			ret_domain := jattr.domain.type_spec;
		END_IF;
		s := '\n  class ' + jattr.name + ' extends StepCoreObjectCondition {\n' 
		+ '    ' + jattr.jclass.name + ' self;\n' 
		+ '    public ' + jattr.name + ' (' + jattr.jclass.name + ' s) { self = s; }\n' 
		+ '    public boolean accept(StepCoreObject obj) {\n' 
		+ '      if (obj instanceof ' + jattr.inverted_attr_owner_class_name + ') {\n';

		IF ( 'PLATYPUS_DICTIONARY_SCHEMA.AGGREGATION_TYPE' IN
				 TYPEOF ( jattr.inverted_jattr.domain ) ) THEN
			s :=
			 s +
			 '        if (((' +
			 jattr.inverted_attr_owner_class_name +
			 ')obj).' +
			 jattr.inverted_attr_get_accessor_name +
			 '().contains(self)) {\n' 
			+ '          return true;\n' 
			+ '        }\n';
		ELSE
			s :=
			 s +
			 '        if (((' +
			 jattr.inverted_attr_owner_class_name +
			 ')obj).' +
			 jattr.inverted_attr_get_accessor_name +
			 '().equals(self)) {\n' 
			+ '          return true;\n' 
			+ '        }\n';
		END_IF;
		s := s + '      }\n' 
		+ '      return false; \n' 
		+ '    }\n' 
		+ '  }\n' 
		+
		 '  public ' +
		 ret_domain +
		 ' ' +
		 jattr.get_accessor_name +
		 '(step.core.StepCoreRepository _repo) { \n';

		IF ( EXISTS ( jattr.attr.min_cardinality ) ) THEN
			s := s + '    return ((' + ret_domain + ')_repo.select( new ' + jattr.name + '(this)));';
		ELSE
			s := s + '    return ((' + ret_domain + ')_repo.detect( new ' + jattr.name + '(this)));';
		END_IF;
		s := s + '\n  }\n';
		RETURN ( s );
	END_FUNCTION;

	ENTITY domain_code_getter_data 
		ABSTRACT SUPERTYPE;
	END_ENTITY;

	ENTITY domain_code_getter_replace_spec_data 
		SUBTYPE OF ( domain_code_getter_data );
		holder : entity_instance;
		get_accessor : STRING;
		set_accessor : STRING;
		rm_accessor : STRING;
		holder_name : STRING;
		key : STRING;
	END_ENTITY;

	ENTITY domain_code_getter 
		SUBTYPE OF ( entity_instance );
		data : domain_code_getter_data;
	DERIVE
		accept_string_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_binary_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_integer_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_real_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_boolean_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_logical_type : entity_instance :=
		 domain_code ( ) ||
		 simple_type_domain_code ( ) ||
		 SELF;
		accept_named_type_reference : entity_instance :=
		 ( domain_code_getter ( data ) ||
			 SELF.ref ).accepted;
		accept_defined_type_reference : entity_instance :=
		 ( domain_code_getter ( data ) ||
			 SELF.ref ).accepted;
		accept_entity_definition_reference : entity_instance :=
		 ( domain_code_getter ( data ) ||
			 SELF.ref ).accepted;
		accept_defined_type : entity_instance :=
		 ( domain_code_getter ( data ) ||
			 SELF.domain ).accepted;
		accept_entity_definition : entity_instance :=
		 domain_code ( ) ||
		 entity_definition_domain_code ( ) ||
		 SELF;
		accept_list_type : entity_instance :=
		 domain_code ( ) ||
		 aggregation_type_domain_code ( ) ||
		 SELF;
		accept_array_type : entity_instance :=
		 domain_code ( ) ||
		 aggregation_type_domain_code ( ) ||
		 SELF;
		accept_set_type : entity_instance :=
		 domain_code ( ) ||
		 aggregation_type_domain_code ( ) ||
		 SELF;
		accept_bag_type : entity_instance :=
		 domain_code ( ) ||
		 aggregation_type_domain_code ( ) ||
		 SELF;
		accept_select_type : entity_instance :=
		 domain_code ( ) ||
		 select_type_domain_code ( ) ||
		 SELF;
		accept_enumeration_type : entity_instance :=
		 domain_code ( ) ||
		 enumeration_type_domain_code ( ) ||
		 SELF;
	END_ENTITY;

	ENTITY domain_code 
		SUBTYPE OF ( entity_instance );
	DERIVE
		replace_spec : STRING := '';
		generic_value_convertion_spec : STRING :=
		 'return (' + SELF.data.jattr.domain.type_spec + ') convertedStepValue(repo, stepVal);';
	END_ENTITY;

	ENTITY simple_type_domain_code 
		SUBTYPE OF ( domain_code );
	DERIVE
		SELF\domain_code.replace_spec : STRING := '';
	END_ENTITY;

	ENTITY entity_definition_domain_code 
		SUBTYPE OF ( domain_code );
	DERIVE
		SELF\domain_code.replace_spec : STRING := entity_definition_replace_spec ( SELF );
	END_ENTITY;

	ENTITY aggregation_type_domain_code 
		SUBTYPE OF ( domain_code );
	DERIVE
		SELF\domain_code.replace_spec : STRING := aggregation_type_replace_spec ( SELF );
	END_ENTITY;

	FUNCTION aggregation_type_replace_spec ( code_getter : aggregation_type_domain_code ) : STRING;
		LOCAL 
			code : STRING := '';
			elem_type : entity_instance := basic_domain ( code_getter.element_type );
			elem_type_spec : STRING := elem_type.type_spec;
			itor : STRING := 'itor' + code_getter.data.key;
			element_type_code : STRING :=
			 ( ( domain_code_getter ( domain_code_getter_data ( ) ||
						 domain_code_getter_replace_spec_data ( code_getter,
							 itor + '.next',
							 itor + '.set',
							 itor + '.remove',
							 itor + '.next',
							 code_getter.data.key + 'i' ) ) ||
					 code_getter.element_type ).accepted ).replace_spec;
		END_LOCAL;

		IF ( element_type_code > '' ) THEN
			IF ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN TYPEOF ( code_getter ) ) OR
				 ( 'PLATYPUS_DICTIONARY_SCHEMA.ARRAY_TYPE' IN
					 TYPEOF ( code_getter ) ) THEN
				code :=
				 '    for (ListIterator<' +
				 elem_type_spec +
				 '> ' +
				 itor +
				 ' = ' +
				 code_getter.data.get_accessor +
				 '().listIterator(); ' +
				 itor +
				 '.hasNext(); ) {\n' 
				+ '    ' + element_type_code + '    }\n';
			ELSE
				IF ( 'PLATYPUS_DICTIONARY_SCHEMA.AGGREGATION_TYPE' IN
						 TYPEOF ( elem_type ) ) THEN
					code :=
					 '    for (Iterator<' +
					 elem_type_spec +
					 '> ' +
					 itor +
					 ' = ' +
					 code_getter.data.get_accessor +
					 '().iterator(); ' +
					 itor +
					 '.hasNext(); ) {\n' 
					+ '    ' + element_type_code + '    }\n';
				ELSE
					IF ( 'PLATYPUS_DICTIONARY_SCHEMA.BAG_TYPE' IN
							 TYPEOF ( code_getter ) ) THEN
						code := '    {\n' 
						+
						 '      ArrayList<' +
						 elem_type_spec +
						 '> v = ' +
						 code_getter.data.get_accessor +
						 '();\n' 
						+ '      int cpt = 0;\n' 
						+ '      while (v.remove(oldObj)) {\n' 
						+ '        done = true;\n' 
						+ '        cpt++; \n' 
						+ '      }\n' 
						+ '      if (newObj != null) {\n' 
						+
						 '          for (int n = 0; n < cpt; n++) v.add((' +
						 elem_type_spec +
						 ')newObj);\n' 
						+ '      }\n' 
						+ '    }\n';
					ELSE
						code := '    {\n' 
						+
						 '      ArrayList<' +
						 elem_type_spec +
						 '> v = ' +
						 code_getter.data.get_accessor +
						 '();\n' 
						+ '      if (v.remove(oldObj)) {\n' 
						+ '        done = true;\n' 
						+ '        if (newObj != null) {\n' 
						+ '          v.add((' + elem_type_spec + ')newObj);\n' 
						+ '        }\n' 
						+ '      }\n' 
						+ '    }\n';
					END_IF;
				END_IF;
			END_IF;
		END_IF;
		RETURN ( code );
	END_FUNCTION;

	ENTITY select_type_domain_code 
		SUBTYPE OF ( domain_code );
	DERIVE
		SELF\domain_code.replace_spec : STRING := select_type_replace_spec ( SELF );
	END_ENTITY;

	ENTITY enumeration_type_domain_code 
		SUBTYPE OF ( domain_code );
	DERIVE
		SELF\domain_code.replace_spec : STRING := '';
		SELF\domain_code.generic_value_convertion_spec : STRING :=
		 'return ' +
		 SELF.data.jattr.domain.type_spec +
		 '.fromString((String) convertedStepValue(repo, stepVal));';
	END_ENTITY;

	FUNCTION entity_definition_replace_spec ( code_getter : entity_definition_domain_code ) : STRING;
		LOCAL 
			code : STRING := '';
		END_LOCAL;

		IF ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN TYPEOF ( code_getter.data.holder ) ) OR
			 ( 'PLATYPUS_DICTIONARY_SCHEMA.BAG_TYPE' IN
				 TYPEOF ( code_getter.data.holder ) ) OR
			 ( 'PLATYPUS_DICTIONARY_SCHEMA.SET_TYPE' IN
				 TYPEOF ( code_getter.data.holder ) ) THEN
			IF ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN
					 TYPEOF ( code_getter.data.holder ) ) THEN
				RETURN ( '  if (' + code_getter.data.get_accessor + '() == oldObj ) {\n' 
					+ '        if (newObj == null) {\n' 
					+ '          ' + code_getter.data.rm_accessor + '();\n' 
					+ '        } else {\n' 
					+
					 '          ' +
					 code_getter.data.set_accessor +
					 '((' +
					 basic_domain ( code_getter\entity_definition ).type_spec +
					 ')newObj);\n' 
					+ '        }\n' 
					+ '        done = true;\n' 
					+ '      }\n' );
			ELSE
				RETURN ( ' (* not empty needed *)' );
			END_IF;
		ELSE
			RETURN ( '    if (' + code_getter.data.get_accessor + '() == oldObj ) {\n' 
				+
				 '      ' +
				 code_getter.data.set_accessor +
				 '((' +
				 basic_domain ( code_getter\entity_definition ).type_spec +
				 ') newObj);\n' 
				+ '      done = true;\n' 
				+ '    }\n' );
		END_IF;
	END_FUNCTION;

	FUNCTION select_type_replace_spec ( code_getter : select_type_domain_code ) : STRING;
		LOCAL 
			code : STRING := '';
		END_LOCAL;

		IF ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN TYPEOF ( code_getter.data.holder ) ) OR
			 ( 'PLATYPUS_DICTIONARY_SCHEMA.BAG_TYPE' IN
				 TYPEOF ( code_getter.data.holder ) ) OR
			 ( 'PLATYPUS_DICTIONARY_SCHEMA.SET_TYPE' IN
				 TYPEOF ( code_getter.data.holder ) ) THEN
			IF ( 'PLATYPUS_DICTIONARY_SCHEMA.LIST_TYPE' IN
					 TYPEOF ( code_getter.data.holder ) ) THEN
				RETURN ( '  if (' + code_getter.data.get_accessor + '() == oldObj ) {\n' 
					+ '        if (newObj == null) {\n' 
					+ '          ' + code_getter.data.rm_accessor + '();\n' 
					+ '        } else {\n' 
					+ '          ' + code_getter.data.set_accessor + '(newObj);\n' 
					+ '        }\n' 
					+ '        done = true;\n' 
					+ '      }\n' );
			ELSE
				RETURN ( ' (* not empty needed *) ' );
			END_IF;
		ELSE
			RETURN ( '    if (' + code_getter.data.get_accessor + '() == oldObj ) {\n' 
				+ '      ' + code_getter.data.set_accessor + '(newObj);\n' 
				+ '      done = true;\n' 
				+ '    }\n' );
		END_IF;
	END_FUNCTION;

	FUNCTION simple_type_generic_value_convertion_spec ( code_getter : simple_type_domain_code ) : STRING;
		LOCAL 
			jattr : java_explicit_attribute := code_getter.data.jattr;
			code : STRING;
		END_LOCAL;
		code :=
		 '    obj.' +
		 jattr.set_accessor_name +
		 '(' +
		 jattr.name +
		 '(repo, (StepInternalRepresentation) si));\n';
		RETURN ( code );
	END_FUNCTION;

	ENTITY domain_code_getter_convertion_spec_data 
		SUBTYPE OF ( domain_code_getter_data );
		jattr : java_attribute;
	END_ENTITY;
END_SCHEMA;