Appendix

    public enum Gender { MALE, FEMALE };

    public int    getAge();

    public String getName();

    public Gender getGender();

}

public interface Employee extends Person {

    public long   getSalary();

}

public interface Manager extends Employee {

}

public interface Department {

    public enum Kind {SALES, DEVELOPMENT, 

                      ACCOUNTING, HUMAN_RESOURCES}

    public Department.Kind getKind();

    public String          getName();

    public Manager         getManager();

    public Set<Employee>   getEmployees();

}

public interface Corporation {

    public Set<Department> getDepartments();

}

*  find all managers of all departments with an employee 

*  older than 65

*/

Manager[] find(Corporation c) {

               List<Manager> result = new ArrayList<>();

               for (Department d : c.getDepartments()) {

                              for (Employee e : d.getEmployees()) {

                                             if (e.getAge() > 65) {

                                                            result.add(d.getManager());

                                             }

                              }

               }

               return result.toArray(new Manager[0]);

}

*   find all managers of all departments with an employee 

*   older than 65

*/

Manager[] find(Corporation c) {

  return

  c.getDepartments().stream()                                // 1

                    .filter(d -> d.getEmployees().stream()   // 2

                                  .map(Employee::getAge)     // 3

                                  .anyMatch(a -> a>65))      // 4

                    .map(Department::getManager)             // 5

                    .collect(Collectors.toList())            // 6

                    .toArray(new Manager[0]);                // 7

}

*   find all managers of all departments with an employee 

*   older than 65

*/

Manager[] find(Corporation c) {

  return

  c.getDepartments(). parallelStream ()                        // 1

                    .filter(

                      d -> d.getEmployees(). parallelStream () // 2

                    .map(Employee::getAge)                   // 3

                    .anyMatch(a -> a>65))                    // 4

  .map(Department::getManager)                               // 5

  .collect(Collectors.toList())                              // 6

  .toArray(new Manager[0]);                                  // 7

}

*   find all managers of all departments with an employee 

*   older than 65

*/

    private static Manager[] find(Corporation c) {

        class FinderTask extends RecursiveTask<List<Manager>> {

            private final Department[] departments;

            private final int from, to;

            private final int targetBatchSize = 2;

            public FinderTask(Department[] departments,

                              int from, int to)   {

                this.departments = departments;

                this.from = from;

                this.to = to;

            }

            private List<Manager> findSequentially() {

                List<Manager> result = new ArrayList<>();

                 for (int i=from;i<to;i++) {

                     Department d =  departments[i];

                    for (Employee e : d.getEmployees()) {

                        if (e.getAge() > 65) {

                            result.add(d.getManager());

                        }

                    }

                }

                return result;

            }

            public List<Manager> compute() {

                if (to-from < targetBatchSize)  

                    return findSequentially();

                int half = (to-from)/2;

                FinderTask task1 

                  = new FinderTask(departments,from,from+half);

                FinderTask task2 

                  = new FinderTask(departments,from+half,to);

                invokeAll(task1,task2);

                try {

                    List<Manager> result = task1.get();

                    result.addAll(task2.get());

                    return result;

                } catch (final InterruptedException | 

                               ExecutionException e) {

                    throw new RuntimeException(e);

                }

            }

        }

        Department[] departments 

           = c.getDepartments().toArray(new Department[0]);

        return ForkJoinPool

              .commonPool()

              .invoke(new FinderTask(departments,0, 

                                     departments.length))

              .toArray(new Manager[0]);

    }

    @FunctionalInterface

    public static interface VoidCriticalRegion {

        void apply();

    }

    public static void withLock(

       Lock lock, 

       VoidCriticalRegion region) {

        lock.lock();

        try {

            region.apply();

        } finally {

            lock.unlock();

        }

    }

    @FunctionalInterface

    public static i nterface IntCriticalRegion {

        int apply();

    }

    public static int withLock(

       Lock lock,

       IntCriticalRegion region)  {

        lock.lock();

        try {

            return region.apply();

        } finally {

            lock.unlock();

        }

    }

    @FunctionalInterface

    public static interface VoidIOECriticalRegion {

        void apply() throws IOException;

    }

    public static void withLockAndIOE(

       Lock lock,                   

       VoidIOECriticalRegion region) 

       throws IOException {

        lock.lock();

        try {

            region.apply();

        } finally {

            lock.unlock();

        }

    }

}

        private Lock lock = new ReentrantLock();

        private int[] array = new int[16];

         private int sp = -1;

        private void resize() {

             // todo later - for now throw index out of bounds

            array[sp] = 0;

        }

        public void push(int e) {

            withLock(lock, () -> {

                if (++sp >= array.length)

                    resize();

                array[sp] = e;

            });

        }

        public int pop() {

            return withLock(lock, () -> {

                if (sp < 0)

                    throw new NoSuchElementException();

                else

                    return (array[sp--]);

            });

        }

}