Category1
\--Category2
     \--Category2a
          \--Note2
     \--Category2b
     \--Note1
\--Category3

class Notebook
{
	contains Note[] notes opposite notebook
	contains Category[] categories opposite notebook
}
  
class Note 
{
	String text
	container Notebook notebook opposite notes
        refers Category[] categories opposite notes
}
 
class Category
{
	refers Note[] notes opposite categories
	refers Note[] allNotes
	contains Category[] children opposite parent
	container Notebook notebook opposite categories
	container Category parent opposite children
}

@DerivedFeature
pattern allNotes(C: Category, N: Note) {
	Category.notes(C, N);
}

/*
 * Subcategory relation
 */
pattern subCategory(c : Category, s : Category) {
  Category.children(c, s);
}

/*
 * List of all categories contained in the selected Category 'c'. The result also includes 'c'.
pattern allSubCategories(c : Category, s : Category) {
  c == s;
} or {
  //This is required as find subCategory+ does no return direct relations; and there is no find subCategory* support in the language
  find subCategory(c, s);
} or {
  find subCategory+(c, s);
}

@DerivedFeature
pattern allNotes(c: Category, n: Note) {
  find allSubCategories(c, s);	
  Category.notes(s, n);
}

...or {find subCategories(This, Child);}...

private pattern subCategories(This: Category, Child: Category) {
	Category.children(This, Child);
}

private pattern thisAndSubCategories(This: Category, Child: Category) {
	find subCategories+(This, Child);
} or {
	This == Child;
}

@DerivedFeature
pattern allNotes(This: Category, Notes: Note) {
	find thisAndSubCategories(This, Child);
	Category.notes(Child, Notes);
}