Derived feature example

ensureOneResult

@QueryBasedFeature
pattern singleFeature(This : SourceType, Target : TargetType){
 find internalQuery(This, Target);
 1 == count find internalQuery(This, Target);
}

private pattern internalQuery(This : SourceType, Target : TargetType){
 // actual query definition
}

@Constraint(location = "This", severity = "error",
   message="Multiple values for $This.name$.singleFeature!")
pattern singleFeatureInvalid(This : SourceType){
 1 < count find internalQuery(This, _Target);
}

plugin.xml

<extension
         id="school.incquery.school.incquery.wellbehavedContribution"
         name=""
         point="org.eclipse.viatra2.emf.incquery.base.wellbehaving.derived.features">
      <wellbehaving-derived-feature
            classifier-name="School"
            feature-name="numberOfTeachers"
            package-nsUri="http:///school.ecore">
      </wellbehaving-derived-feature>
      <wellbehaving-derived-feature
            classifier-name="School"
            feature-name="teachersWithMostCourses"
            package-nsUri="http:///school.ecore">
      </wellbehaving-derived-feature>
      <wellbehaving-derived-feature
            classifier-name="School"
            feature-name="lastYear"
            package-nsUri="http:///school.ecore">
      </wellbehaving-derived-feature>
   </extension>

school-derived-base.eiq

import "http:///school.ecore"

@QueryBasedFeature(feature = "numberOfTeachers", kind = "counter")
pattern teachers(School : School, Teacher : Teacher) = {
   School.teachers(School,Teacher);
}

pattern coursesOfTeacher(Teacher : Teacher, Course :  Course) = {
   Teacher.courses(Teacher,Course);
}

@QueryBasedFeature
pattern teacherWithMostCourses(School : School, Teacher : Teacher) = {
   find teachers(School,Teacher);
   neg find moreCourses(Teacher);
}

pattern moreCourses(Teacher : Teacher) = {
	N == count find coursesOfTeacher(Teacher,Course);
    M == count find coursesOfTeacher(Teacher2,Course2);
    check((N as Integer) < (M as Integer));
}

@QueryBasedFeature
pattern lastYear(School : School, Year : Year) = {
   School.years(School,Year);
   neg find laterYear(Year);
}

pattern laterYear(Year : Year) = {
	Year.startingDate(Year, Date);
	Year.startingDate(Year2, Date2);
	check((Date as Integer) < (Date2 as Integer));
}

SchoolImpl.java

// Query based features
private IncqueryFeatureHandler numberOfSchoolsHandler;
private IncqueryFeatureHandler lastYearHandler;
private IncqueryFeatureHandler teachersWithMostCourses;

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 */
protected SchoolImpl() {
 super();
 IMatcherFactory tmf = MatcherFactoryRegistry.getMatcherFactory("teachers");
 IMatcherFactory lyf = MatcherFactoryRegistry.getMatcherFactory("lastYear");
 IMatcherFactory twmcf = MatcherFactoryRegistry.getMatcherFactory("teacherWithMostCourses");
 if (tmf != null) {
  numberOfSchoolsHandler = IncqueryFeatureHelper.createHandler(this,
   SchoolPackage.Literals.SCHOOL__NUMBER_OF_TEACHERS, tmf, "School", null, FeatureKind.COUNTER);
 }
 if (lyf != null) {
  lastYearHandler = IncqueryFeatureHelper.createHandler(this, SchoolPackage.Literals.SCHOOL__LAST_YEAR,
   lyf, "School", "Year", FeatureKind.SINGLE_REFERENCE);
 }
 if (twmcf != null) {
  teachersWithMostCourses = IncqueryFeatureHelper.createHandler(this,
   SchoolPackage.Literals.SCHOOL__TEACHERS_WITH_MOST_COURSES, twmcf, "School", "Teacher",
   FeatureKind.MANY_REFERENCE);
 }
}

SchoolImpl_getters.java

/**
 * EMF-IncQuery handler for query-based feature numberOfTeachers
 */
private QueryBasedFeatureHandler numberOfTeachersHandler;

/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @derived getter created by EMF-IncQuery for query-based feature numberOfTeachers
 */
public int getNumberOfTeachers() {
 if (numberOfTeachersHandler == null) {
  numberOfTeachersHandler = QueryBasedFeatureHelper.getQueryBasedFeatureHandler(
    this, SchoolPackageImpl.Literals.SCHOOL__NUMBER_OF_TEACHERS,
    "teachers", "School", null, FeatureKind.COUNTER,
    true, false);
 }
 return numberOfTeachersHandler.getIntValue(this);
}

/**
 * EMF-IncQuery handler for query-based feature teachersWithMostCourses
 */
private QueryBasedFeatureHandler teachersWithMostCoursesHandler;

/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @derived getter created by EMF-IncQuery for query-based feature teachersWithMostCourses
 */
public EList<Teacher> getTeachersWithMostCourses() {
 if (teachersWithMostCoursesHandler == null) {
  teachersWithMostCoursesHandler = QueryBasedFeatureHelper.getQueryBasedFeatureHandler(
    this, SchoolPackageImpl.Literals.SCHOOL__TEACHERS_WITH_MOST_COURSES,
    "teachersWithMostCourses", "School", "Teacher", FeatureKind.MANY_REFERENCE,
    true, false);
 }
 return teachersWithMostCoursesHandler.getManyReferenceValueAsEList(this);
}

/**
 * EMF-IncQuery handler for query-based feature lastYear
 */
private QueryBasedFeatureHandler lastYearHandler;

/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @derived getter created by EMF-IncQuery for query-based feature lastYear
 */
public Year basicGetLastYear() {
 if (lastYearHandler == null) {
  lastYearHandler = QueryBasedFeatureHelper.getQueryBasedFeatureHandler(
   this, SchoolPackageImpl.Literals.SCHOOL__LAST_YEAR,
   "lastYear", "School", "Year", FeatureKind.SINGLE_REFERENCE,
   true, false);
 }
 return (school.Year) lastYearHandler.getSingleReferenceValue(this);
}

studentsOfCourse

package school.queries;

import "http:///school.ecore"

@QueryBasedFeature
pattern studentsOfCourse(This : Course, Target : Student) = {
   Course.schoolClass.students(This,Target);
}