package klassen


pattern allTypes(klasse) 
{
	ConcreteClassifier(klasse);
} 
or
{
	AnonymousClass(klasse);
}

public class IncQueryMethodsCC extends AbstractQuery {

	private AdvancedIncQueryEngine engine;
	private Collection<MethodsHighCCMatch> allMatchesCC;
	private Collection<TooLargeMemberContainersMatch> allMatchesMethods;
	private Collection<AlleTypenMatch> allMatchesMemberContainer;

	public IncQueryMethodsCC(ResourceSet resourceSet, String name) {
		super(resourceSet, name);
	}

	@Override
	public void createEngine() {
		try {
			engine = AdvancedIncQueryEngine.createUnmanagedEngine(resourceSet, createBaseIndexOptions());
		} catch (IncQueryException e) {
			e.printStackTrace();
		}
	}

	public BaseIndexOptions createBaseIndexOptions() {
		BaseIndexOptions baseIndexOptions = new BaseIndexOptions();
		baseIndexOptions.setResourceFilterConfiguration(new IBaseIndexResourceFilter() {

			@Override
			public boolean isResourceFiltered(Resource resource) {
				return true;
			}
		});
		return baseIndexOptions;
	}

	@Override
	public void runQuery() {
		try {
			allMatchesCC = engine.getMatcher(MethodsHighCCQuerySpecification.instance()).getAllMatches();

			allMatchesMethods = engine.getMatcher(TooLargeMemberContainersQuerySpecification.instance())
					.getAllMatches();

			allMatchesMemberContainer = engine.getMatcher(AlleTypenQuerySpecification.instance()).getAllMatches();

		} catch (IncQueryException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void doAdditional() {
		filterMethodsForSourceObjectsAndPrintNumber(allMatchesCC);
		filterTypesForSourceObjectsAndPrintNumber(allMatchesMemberContainer);
		filterTypesTooLargeForSourceObjectsAndPrintNumber(allMatchesMethods);
	}

	public void filterMethodsForSourceObjectsAndPrintNumber(Collection<MethodsHighCCMatch> allMatches) {
		List<EObject> resultSet = createList();
		Util.log(" #matches" + allMatches.size());
		for (MethodsHighCCMatch match : allMatches) {
			Member methode = match.getMethod();
			if (isSourceElement(methode)) {
				resultSet.add(methode);
				// Util.log(" " + Util.calulateCompleteMethodName(methode));
			}
		}
		Util.log(" size MethodsCC = " + resultSet.size());
	}

	public void filterTypesForSourceObjectsAndPrintNumber(Collection<AlleTypenMatch> allMatches) {
		List<EObject> resultSet = createList();
		Util.log(" #matches" + allMatches.size());
		for (AlleTypenMatch match : allMatches) {
			MemberContainer type = match.getInput();
			if (isSourceElement(type)) {
				resultSet.add(type);
			}
		}
		Util.log(" size All Types = " + resultSet.size());
	}

	public void filterTypesTooLargeForSourceObjectsAndPrintNumber(Collection<TooLargeMemberContainersMatch> allMatches) {
		List<EObject> resultSet = createList();
		Util.log(" #matches" + allMatches.size());
		for (TooLargeMemberContainersMatch match : allMatches) {
			MemberContainer type = match.getMemberContainer();
			if (isSourceElement(type)) {
				resultSet.add(type);
			}
		}
		Util.log(" size Too Large Types = " + resultSet.size());
	}

	public void dispose() {
		engine.dispose();
	}
}


public abstract class AbstractQuery {

	ResourceSet resourceSet;

	public AbstractQuery(ResourceSet resourceSet, String name) {
		super();
		this.resourceSet = resourceSet;
		this.name = name;
	}

	String name;
	long time;

	public void runAll() {
		log(name);

		// MemoryUsageMeter.activate();

		startTime();
		createEngine();
		log("engineloadtime=" + calculateUsedSeconds());

		startTime();
		runQuery();
		log("querytime=" + calculateUsedSeconds());

		doAdditional();
	}

	public double calculateUsedSeconds() {
		return convertTimeInSeconds(stopTime());
	};

	public abstract void doAdditional();

	public abstract void runQuery();

	public abstract void createEngine();

	public void startTime() {
		time = getNanoTime();
	}

	public long stopTime() {
		return getNanoTime() - time;
	}

}

@Override
public boolean isResourceFiltered(Resource resource) {
  return true;
}