class Branch {

        private final ConstructorHolder holder;
        private final Map<String, Branch> children;

        private Branch(Constructor<?> constructor) {
            this.holder = new ConstructorHolder(constructor);
            this.children = new ConcurrentHashMap<>();
        }

        public ConstructorHolder find(List<String> keyPath) {
            return find(0, keyPath);
        }

        private ConstructorHolder find(int i, List<String> keyPath) {<FILL_FUNCTION_BODY>}

        @Override
        public String toString() {
            return children.toString();
        }
    }

            // If we are at the last key, return our constructor.
            if (i == keyPath.size()) {
                return holder;

                // If there are still keys in the path, find the one mentioned in
                // the i:th key and recurse into that branch
            } else if (i < keyPath.size()) {
                return children.computeIfAbsent(
                    keyPath.get(i), k -> new Branch(parent -> {
                    final AbstractDocumentProperty<?> castedParent
                        = (AbstractDocumentProperty<?>) parent;
                    return new DefaultDocumentProperty(castedParent, k);
                })
                ).find(i + 1, keyPath);

                // If we are out of keys, something is terrible wrong...
            } else {
                throw new UnsupportedOperationException(
                    "iterator is outside the specified keyPath."
                );
            }
        
<no_super_class>