Resolve all children of the top most document block.

@param entry the entry to contain the field to be walked
@param field the id of the field to be walked.
184491
private static void resolveRichDocument(CDAEntry entry, CDAField field) {
    final Map<String, Object> rawValue = (Map<String, Object>) entry.rawFields().get(field.id());
    if (rawValue == null) {
      return;
    }

    for (final String locale : rawValue.keySet()) {
      final Object raw = rawValue.get(locale);
      if (raw == null || raw instanceof CDARichNode) {
        // ignore null and already parsed values
        continue;
      }

      final Map<String, Object> map = (Map<String, Object>) rawValue.get(locale);
      entry.setField(locale, field.id(), RESOLVER_MAP.get("document").resolve(map));
    }
  }
681507
public void removeDeleted(CmsClientSitemapEntry entry) {

        for (CmsClientSitemapEntry child : entry.getSubEntries()) {
            removeDeleted(child);
        }
        m_treeItems.remove(entry.getId());
    }
1082880
@Override
  protected void visitFieldAccessNode(FieldAccessNode node) {
    // simplify children first
    visitChildren(node);
    ExprNode baseExpr = node.getChild(0);
    if (baseExpr instanceof RecordLiteralNode) {
      RecordLiteralNode recordLiteral = (RecordLiteralNode) baseExpr;
      for (int i = 0; i < recordLiteral.numChildren(); i++) {
        if (recordLiteral.getKey(i).identifier().equals(node.getFieldName())) {
          node.getParent().replaceChild(node, recordLiteral.getChild(i));
          return;
        }
      }
      // replace with null?  this should have been a compiler error.
    } else if (baseExpr instanceof ProtoInitNode) {
      ProtoInitNode protoInit = (ProtoInitNode) baseExpr;
      int fieldIndex = -1;
      for (int i = 0; i < protoInit.getParamNames().size(); i++) {
        if (protoInit.getParamNames().get(i).identifier().equals(node.getFieldName())) {
          fieldIndex = i;
          break;
        }
      }
      if (fieldIndex != -1) {
        node.getParent().replaceChild(node, protoInit.getChild(fieldIndex));
      } else {
        // here we could replace with a default value or null, but for now, do nothing, rather than
        // implement proto default field semantics.
      }
    }
  }
825716
private int findIndex(Entry<?> entry) {
        int childrenSize = getChildren().size();

        for (int i = 0; i < childrenSize; i++) {
            Node node = getChildren().get(i);
            if (node instanceof DayEntryView) {
                DayEntryView view = (DayEntryView) node;
                Entry<?> viewEntry = view.getEntry();
                if (viewEntry.getStartAsZonedDateTime().isAfter(entry.getStartAsZonedDateTime())) {
                    return i;
                }
            }
        }

        return childrenSize;
    }
550159
public Source resolve(Field field) {
        
        /**
         * As promised the registrar simply abstracts away the internal 
         * resolution implementations, throwing an error if all of them fail to
         * come up with a source for the field.
         */
        for (Resolver resolver : resolvers) {
            Source source = resolver.resolve(field);
            
            /**
             * Per the dependency resolver contract, a return value of null 
             * means no error occurred, but the resolver failed to resolve the
             * type anyway, so we can move on to the next resolver.
             */
            if (source != null) {
                return source;
            }
        }
        
        /**
         * If no resolver succeeded in generating an instance source, we've got
         * a problem: we need to inject a field but we have no way to get an
         * instance of it!
         */
        throw new UnexpectedImplementationCountException(
            field.getType(), 
            noImplementations);
    }
696369
private void categoryTreeToList(List<CmsCategoryBean> categoryList, List<CmsCategoryTreeEntry> entries) {

        if (entries == null) {
            return;
        }
        // skipping the root tree entry where the path property is empty
        for (CmsCategoryTreeEntry entry : entries) {
            CmsCategoryBean bean = new CmsCategoryBean(entry);
            categoryList.add(bean);
            categoryTreeToList(categoryList, entry.getChildren());
        }
    }
825498
@Override
    void addEntry(int hash, K key, V value, int bucketIndex) {
	super.addEntry(hash, key, value, bucketIndex);

	// Remove eldest entry if instructed
	Entry<K, V> eldest = header.after;
	if (removeEldestEntry(eldest)) {
	    removeEntryForKey(eldest.key);
	}
    }
780373
@Override
   protected String resolveField(Field field)
   {
      final String fallBackName = field.getName();
      final String resourceName = field.getAnnotation(Resource.class).name();

      return getName(resourceName, fallBackName);
   }
1262916
private static <A, B> Entry<A, B> createEntry(A text, B field) {
        return new SimpleImmutableEntry<>(text, field);
    }
726540
private void appendEntry(Map.Entry<String, EDBObjectEntry> entry, StringBuilder builder) {
        if (builder.length() > 2) {
            builder.append(",");
        }
        builder.append(" \"").append(entry.getKey()).append("\"");
        builder.append(" : ").append(entry.getValue());
    }
754226
def resolve_field(self, field):
        '''
        
        '''
        if isinstance(field, BaseField):
            return field
        name = field
        if name.startswith('/'):
            return self.resolve_absolute_name(name)
        resolved_field = self.scan_for_field(name)
        if not resolved_field:
            container = self.enclosing
            if container:
                resolved_field = container.resolve_field(name)
        if not resolved_field:
            raise KittyException('Could not resolve field by name (%s)' % name)
        return resolved_field
118768
public void delTemplateEntry(String template, Object entry) {
        if (htod.delTemplateEntry(template, entry) == HTODDynacache.DISK_EXCEPTION) {
            stopOnError(this.htod.diskCacheException);
        }
    }
89819
protected void insertLeafEntry(E entry) {
    lastInsertedEntry = entry;
    // choose subtree for insertion
    IndexTreePath<E> subtree = choosePath(getRootPath(), entry, height, 1);

    if(getLogger().isDebugging()) {
      getLogger().debugFine("insertion-subtree " + subtree);
    }

    N parent = getNode(subtree.getEntry());
    parent.addLeafEntry(entry);
    writeNode(parent);

    // adjust the tree from subtree to root
    adjustTree(subtree);
  }
158445
protected void _closeChild()
    {
        if (_child != null) {
            Object value = _child._safeFinish();
            _map.put(_fieldName, value);
            _child = null;
        }
    }
15188
public function iFillInSelect2InputWithAndSelect($field, $value, $entry)
    {
        $page = $this->getSession()->getPage();

        $this->openField($page, $field);
        $this->fillSearchField($page, $field, $value);
        $this->selectValue($page, $field, $entry, $this->timeout);
    }
409335
private void treeWalker(Node node, int level, List<PathQueryMatcher> queryMatchers, List<Node> collector) {
        MatchType matchType = queryMatchers.get(level).match(level, node);
        if(matchType == MatchType.NOT_A_MATCH) {
            // no reason to scan deeper
            //noinspection UnnecessaryReturnStatement
            return;
        } else if(matchType == MatchType.NODE_MATCH) {
            // we have a match
            if(level == queryMatchers.size()-1) {
                // full path match
                collector.add(node);
            } else if(node instanceof Element) {
                // scan deeper
                Element element = (Element) node;
                List<Node> childElements = element.getChildElements();
                for (Node childElement : childElements) {
                    treeWalker(childElement, level+1, queryMatchers, collector);
                }
            }
        } else {
            throw new PathQueryException("Unknown MatchType: " + matchType);
        }
    }
597438
public boolean add(E entry)
	{
		super.add(entry);
		
		if(this.size() > this.maxSize)
		{
			super.removeRange(0, this.size() - maxSize);
		}
		
		return true;
	}