grammar my.grammar.Grammar  with	org.eclipse.xtext.xbase.Xbase

generate grammar "http://myGrammar/Grammar"

"uri.of.the.referenced.Model.ecore" as otherModel
Model:
	imports+=Import+
	constraint+=Constraint+
	;
Constraint:
	'constraint' name=ID '{'
	ref=[otherModel::Entity|FQN]
	query=XExpression 
	'}'
	;

Import:
	'import' importedNamespace=FqnWithWildCard;

FqnWithWildCard:
	FQN ('.*')?;

FQN:
	ID ('.' ID)*;
	

def dispatch void infer(Constraint element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
	   		
	   		if(element.ref != null	)
	   			if(element.ref.eIsProxy) {
	   				EcoreUtil::resolve(element.ref,element.eResource.resourceSet)
	   				element.eResource.resourceSet.getResource(EcoreUtil::getURI(element.ref).trimFragment,true)
	   				EcoreUtil::resolve(element.ref,element.eResource.resourceSet)
	   			}
	   		
	   			
	   			
		   		acceptor.accept(element.ref.toClass(element.ref.id)).initializeLater([
		   			    
		   			var f = element.ref.root.toField(element.ref.root.id,element.ref.root.newTypeRef(Boolean::TYPE))
		   			f.setVisibility(JvmVisibility::PUBLIC)
		   			members += f
		   			for (group: element.ref.root.children){
		   				for( feature: group.features ) {
		   					 var cf = feature.toField(feature.id,feature.newTypeRef(Boolean::TYPE))
		   					 cf.setVisibility(JvmVisibility::PUBLIC)
		   				         members += cf
		   					
							if (!feature.children.empty){
								members+= addChildFeaturesAsMembers(feature, members)
							}
							
		   			}
		   				
		   					   			
		   			members+=element.toMethod("checkConstraint",element.newTypeRef(Boolean::TYPE)) [
		   				body = element.query
		   			]
		   			])
   			}
}
   		
def EList<JvmMember> addChildFeaturesAsMembers(Feature feature, EList<JvmMember> members){
	        	val groups = feature.children
	      		var counter = 0
	       
			while (counter <  groups.size){
			
				for (childFeature: groups.get(counter).features){
					var cf = childFeature.toField(childFeature.id,childFeature.newTypeRef(Boolean::TYPE))
		   			cf.setVisibility(JvmVisibility::PUBLIC)
		   			members += cf
				
					if (!childFeature.children.empty){
						members+= addChildFeaturesAsMembers(childFeature, members)
					}
				}
			counter = counter+1
				
			}
					
			return members	
			
   			
} 

public class MyGrammarIdentifiableSimpleNameProvider  extends
		IdentifiableSimpleNameProvider {

	
	
	@Override
	public String getSimpleName(JvmIdentifiableElement element) {
		if (element instanceof JvmGenericType)
			return "this";
		return super.getSimpleName(element);
	}
}

public class MyGrammarInterpreter extends XbaseInterpreter {

	@Inject
	private IJvmModelAssociations jvmModelAssociator;

	@Override
	protected Object featureCallField(JvmField jvmField, Object receiver) {
		
		if(receiver instanceof Entity) {
			
			return true	
		}
		return super.featureCallField(jvmField, receiver);
	}	

}

	public java.lang.ClassLoader bindClassLoaderToInstance() {
return getClass().getClassLoader();
}