Data
- 1 -n Fields
- 1- n Groups 
-- each Group can define 1-n Fields again
-- each Group can define 1-n Subgroups

Model
-Common
-- 1-n CommonField
--- 1-n Field
-Data
-- 1 -n Field | CommonField
-- 1- n Group

Common {
	CommonA{
		Text A
		Text B
		Text C
		Text D
	}
	CommonB{
		Date X
		Date Y
	}
}

SomethingA

Fields {
		Integer IntA
		Integer IntB
                type CommonB  // <-- interesting
}
GroupA {
	Fields {
		Integer IntX
                type CommonA // <-- the generator has to know that this cross-ref is inside GroupA
	}
}

ModelRule returns Model:
	 "Common" "{" (commonFields+=CommonFieldsRule)+ "}" |data=DataRule
;

CommonFieldsRule returns CommonField:
	name=ID "{"
		(fields+=FieldRule)+
	"}"	
;

DataRule returns Data: 
	name=ID
	("Fields" "{"
		(fields+=FieldRule)+
	"}")*
	(groups+=GroupRule)+
;


GroupRule returns Group:
		name=ID "{"
		("Fields" "{"
			(fields+=SingleFieldOrCommonFieldRefRule)+
		"}")*
		(groups+=GroupRule)*
	"}"
;

SingleFieldOrCommonFieldRefRule returns Field:
	CommonFieldRefRule | FieldRule
;

CommonFieldRefRule returns CommonFieldRef:
	"type" fieldRef=[CommonField]
;


FieldRule returns SingleField:
	name=ID
;

class DatenversorgungDslGenerator extends AbstractGenerator {

	@Inject
    private XtextResourceSet resourceSet;

	val crossReferenceAdapter = new ECrossReferenceAdapter()

	override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
		resourceSet.eAdapters.add(crossReferenceAdapter)
		... start codegen
	}
...

	def dispatch CharSequence printData(Group group)'''
		<group.name»>
			«FOR field : group.fields.filter[it.valid]»
				«field.printData»
			«ENDFOR»
			«FOR subgroups : group.groups.filter[it.valid]»
				«subgroups.printData»
			«ENDFOR»
		</group.name»>
	'''
	
	
	
	def dispatch CharSequence printData (CommonFieldRef commonFieldRef)'''
		«FOR field : commonFieldRef.fieldRef.fields»
			field.printData»
		«ENDFOR»
	'''
	
	
	def dispatch CharSequence printData(SingleField field){
		val sb = new StringBuilder("<")
		... append some stuff
		if(field.eContainer instanceof Group){
			sb.append("group=\"" + (field.eContainer as Group).name + "\"")
		}
		else if (field.eContainer instanceof CommonField) {
			// figure out if the CommonField was referenced from within a group
			val settings = crossReferenceAdapter.getInverseReferences(field.eContainer, true) // eContainer of CommonField should be CommonFieldRef which contains the cross-ref
			settings.forEach[
				println(it.EObject)
				val x = (it.EStructuralFeature) as EReference
				if(x.equals(MyPackage.eINSTANCE.commonFieldRef_FieldRef)){
					println(it.EObject)					
				}
			]
		}
		
		return sb.toString
	}