jadex.nfproperty.impl.NFPropertyLoader Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of nfproperty Show documentation
Non functional properties feature
The newest version!
package jadex.nfproperty.impl;

import java.lang.System.Logger.Level;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jadex.common.ClassInfo;
import jadex.common.MethodInfo;
import jadex.core.impl.ComponentManager;
import jadex.micro.MicroClassReader;
import jadex.model.annotation.NameValue;
import jadex.model.modelinfo.ModelInfo;
import jadex.nfproperty.annotation.NFProperties;
import jadex.nfproperty.annotation.NFProperty;
import jadex.nfproperty.annotation.SNameValue;
import jadex.nfproperty.impl.modelinfo.NFPropertyInfo;
import jadex.providedservice.IProvidedServiceFeature;
import jadex.providedservice.impl.service.BasicService;
import jadex.providedservice.impl.service.ProvidedServiceImplementation;
import jadex.providedservice.impl.service.ProvidedServiceInfo;
import jadex.providedservice.impl.service.ProvidedServiceModel;
import jadex.requiredservice.IRequiredServiceFeature;
import jadex.requiredservice.impl.RequiredServiceModel;

public class NFPropertyLoader 
{
	public static Object readFeatureModel(ModelInfo modelinfo, Class clazz, ClassLoader cl)
	{
		Class cma = clazz;
		
		NFPropertyModel model = new NFPropertyModel();
		boolean done = false;
		//boolean tagsdone = false;
		
		while(cma!=null && !cma.equals(Object.class))
		{
			// Take all, upper replace lower
			if(!done && MicroClassReader.isAnnotationPresent(cma, NFProperties.class, cl))
			{
				NFProperties val = (NFProperties)MicroClassReader.getAnnotation(cma, NFProperties.class, cl);
				
				List props = createNFPropertyInfos(val);
				props.forEach(nfp -> model.addComponentProperty(nfp));
				
				// todo!
//				nfpropsdone = val.replace();
			}
			
			// Take all, upper replace lower
			/*if(!tagsdone && MicroClassReader.isAnnotationPresent(cma, Tags.class, cl))
			{
				Tags tags = (Tags)MicroClassReader.getAnnotation(cma, Tags.class, cl);
				
				NFPropertyInfo nfp = createNFPropertyInfo(tags);
				model.addComponentProperty(nfp);
				
				// todo!
//				tagsdone = val.replace();
			}*/
			
			cma = cma.getSuperclass();
		}
		
		// creation of required service nfps happens when required service proxy is created
		// they must be written toplevel - can be associated with reqser when name is same?!
		
		RequiredServiceModel rmodel = (RequiredServiceModel)modelinfo.getFeatureModel(IRequiredServiceFeature.class);
		//Map rsers = rmodel.getRequiredServices();
		//System.out.println("todo: required service nfprops");
		System.getLogger(NFPropertyLoader.class.getName()).log(Level.WARNING, "todo: required service nfprops");
		
//		RequiredServiceInfo[] rsis = new RequiredServiceInfo[reqs.length];
		/*for(int j=0; j nfprops = createNFRProperties(reqs[j].nfprops());
				RequiredServiceInfo rsi = new RequiredServiceInfo(reqs[j].name(), reqs[j].type(), reqs[j].min(), reqs[j].max(),// reqs[j].multiple(), 
					binding, nfprops, Arrays.asList(reqs[j].tags()));
//					configinfo.setRequiredServices(rsis);
				configinfo.addRequiredService(rsi);
			}
		}*/
		
		// creation of provided service nfps happens
		
		ProvidedServiceModel pmodel = (ProvidedServiceModel)modelinfo.getFeatureModel(IProvidedServiceFeature.class);
		if(pmodel!=null)
		{
			ProvidedServiceInfo[] psis = pmodel.getServices();
			for(ProvidedServiceInfo psi: psis)
			{
				ProvidedServiceImplementation impl = psi.getImplementation();
				
				Class implcl = null;
				if(impl.getClazz()!=null)
					implcl = impl.getClazz().getType(ComponentManager.get().getClassLoader());
				else if(impl.getClazz()==null && impl.getValue()==null)
					implcl = clazz; // pojoclass
				
				Map> serprops = createProvidedNFProperties(implcl, psi.getType().getType(ComponentManager.get().getClassLoader()));
			
				if(serprops.get(null)!=null)
				{
					serprops.get(null).forEach(p -> model.addProvidedServiceProperty(psi.getName(), p));
				}
				
				serprops.entrySet().forEach(entry ->
				{
					if(entry.getKey()!=null)
					{
						entry.getValue().forEach(p -> model.addProvidedServiceMethodProperty(psi.getName(), entry.getKey(), p));
					}
				});
			}
		}
				
		return model;
	}
	
	public static List createNFPropertyInfos(NFProperties nfprops)
	{
		List ret = new ArrayList<>();
		for(NFProperty prop: nfprops.value())
		{
			NameValue[] vals = prop.parameters();
			NFPropertyInfo nfp = new NFPropertyInfo(prop.name(), new ClassInfo(prop.value().getName()), SNameValue.createUnparsedExpressionsList(vals));
			ret.add(nfp);
		}
		return ret;
	}
	
	/*public static NFPropertyInfo createNFPropertyInfo(Tags tags)
	{		
		List params = new ArrayList<>();
//		if(val.argumentname().length()>0)
//			params.add(new UnparsedExpression(TagProperty.ARGUMENT, "\"val.argumentname()\""));

		for(int i=0; i0)
			//	params.add(new UnparsedExpression(TagProperty.NAME+"_condition_"+i, tag.include()));
			params.add(new UnparsedExpression(TagProperty.NAME+"_"+i, tag.value()));
		}
		
		NFPropertyInfo nfp = new NFPropertyInfo(TagProperty.NAME, new ClassInfo(TagProperty.class), params);
		
		return nfp;
	}*/
	
	public static Map> createProvidedNFProperties(Class impltype, Class sertype)
	{
		Map> ret = new HashMap>();
		List serprops = new ArrayList();
		ret.put(null, serprops);
		
		List> classes = new ArrayList>();
		Class superclazz = sertype;
		while(superclazz != null && !Object.class.equals(superclazz))
		{
			classes.add(superclazz);
			superclazz = superclazz.getSuperclass();
		}
		
		superclazz = impltype;
		while(superclazz != null && !BasicService.class.equals(superclazz) && !Object.class.equals(superclazz))
		{
			classes.add(superclazz);
			superclazz = superclazz.getSuperclass();
		}
		
		Map meths = new HashMap();
		for(Class sclazz: classes)
		{
			if(sclazz.isAnnotationPresent(NFProperties.class))
			{
				List nfps = createNFPropertyInfos(sclazz.getAnnotation(NFProperties.class));
				nfps.forEach(nfp -> serprops.add(nfp));
			}
			
			/*if(sclazz.isAnnotationPresent(Tags.class))
			{
				NFPropertyInfo nfp = createNFPropertyInfo(sclazz.getAnnotation(Tags.class));
				serprops.add(nfp);
			}*/
			
			Method[] methods = sclazz.getMethods();
			for(Method m : methods)
			{
				if(m.isAnnotationPresent(NFProperties.class))
				{
					MethodInfo mis = new MethodInfo(m.getName(), m.getParameterTypes());
					if(!meths.containsKey(mis))
					{
						meths.put(mis, m);
					}
				}
			}
		}
		
		for(MethodInfo key: meths.keySet())
		{
			List nfps = createNFPropertyInfos(meths.get(key).getAnnotation(NFProperties.class));
			ret.put(key, nfps);
		}
		
		return ret;
	}
	

	
	
	
	/**
	 *  Create a required service info from annotation.
	 * /
	protected static RequiredServiceInfo createRequiredServiceInfo(RequiredService rs, ClassLoader cl)
	{
		RequiredServiceBinding binding = createBinding(rs);
		List nfprops = createNFRProperties(rs.nfprops());
		
		for(NFRProperty prop: rs.nfprops())
		{
			nfprops.add(new NFRPropertyInfo(prop.name(), new ClassInfo(prop.value().getName()), 
				new MethodInfo(prop.methodname(), prop.methodparametertypes())));
		}
		
		RequiredServiceInfo rsis = new RequiredServiceInfo(rs.name(), rs.type(), 
			rs.min(), rs.max(), binding, nfprops, Arrays.asList(rs.tags())); // rs.multiple()
		
		return rsis;
	}*/
	
	
	/**
	 *  Create req service props.
	 * /
	protected static List createNFRProperties(NFRProperty[] nfrp)
	{
		List nfprops = new ArrayList();
		for(NFRProperty prop: nfrp)
		{
			nfprops.add(new NFRPropertyInfo(prop.name(), new ClassInfo(prop.value().getName()), 
				new MethodInfo(prop.methodname(), prop.methodparametertypes())));
		}
		return nfprops;
	}*/
}