Called when the element was added to a bibliography.
327388
def added_to_bibliography(bibliography)
      super

      @key = register(key)

      [:parse_names, :parse_months].each do |parser|
        send(parser) if bibliography.options[parser]
      end

      if bibliography.options.has_key?(:filter)
        [*bibliography.options[:filter]].each do |filter|
          convert!(filter)
        end
      end

      self
    end
470274
public static void lazyInsertAfter(Element newElement, Element after) {
        if (!after.parentNode.contains(newElement)) {
            after.parentNode.insertBefore(newElement, after.nextSibling);
        }
    }
934297
private void newTodo(Event event) {
        if (Key.Enter.match(event)) {
            String text = newTodo.value.trim();
            if (text.length() != 0) {
                TodoItem item = repository.add(text);
                list.appendChild(new TodoItemElement(this, repository, item).element());
                newTodo.value = "";
                update();
            }
        }
    }
1360576
def date_added(self, date_added):
        """"""
        self._indicator_data['dateAdded'] = self._utils.format_datetime(
            date_added, date_format='%Y-%m-%dT%H:%M:%SZ'
        )
13011
function (obj, el, parent) {
      parent.appendChild(el)
      // Fixed elements that do not suffer removal
      if (obj.undo !== undefined && !obj.undo) return
      // Elements which are removed
      els.push(el)
    }
479364
def add_element(self, priority, element, count=None):
        
        if count is None:
            count = next(self.counter)
        entry = [priority, count, element]
        self.element_finder[element] = entry
        heapq.heappush(self.pq, entry)
8116
void addElement(KElement element) {
		if (!this.elements.contains(element)) {
			element.setIndex(this.elements.size());
			this.elements.add(element);
		}
	}
876259
public synchronized void addElement(T element) {
		List<T> origList = ref.get().list;
		boolean isPresent = origList.contains(element);
		if (isPresent) {
			return;
		}
		
		List<T> newList = new ArrayList<T>(origList);
		newList.add(element);
		
		swapWithList(newList);
	}
1235984
public void add(int index, Object element) {

        if (index == size()) {
            add(element);    //Add to the end of this.
        }

        //If index > size() an exception should be thrown with a slightly
        //different message than the exception thrown by getInternal.
        else if (index > size()) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " > " + size());
        } else {
            Node current = getInternal(index);
            Node newNext = new Node(current.data, current.next);

            current.data = element;
            current.next = newNext;

            elementCount++;

            //If they inserted at the last valid index, then a new last element
            //was created, therfore update the last pointer
            if (last == current) {
                last = newNext;
            }
        }
    }
1093451
public void referencedElementUpdated(ModelElementInstance referenceTargetElement, String oldIdentifier, String newIdentifier) {
    for (ModelElementInstance referenceSourceElement : findReferenceSourceElements(referenceTargetElement)) {
      updateReference(referenceSourceElement, oldIdentifier, newIdentifier);
    }
  }
412157
private Element addElement(Document document, Element parent,
			Map<ReportKey, Object> reportsData, ReportKey key, String value) {
		if (reportsData.containsKey(key)) {
			Element child = document.createElement(key.name().toLowerCase());
			child.appendChild(document.createTextNode(value));
			parent.appendChild(child);
			return child;
		}
		return null;
	}
1111926
function () {
            newEdit = {
                type: "textInsert",
                content: newChild.content,
                parentID: newChild.parent.tagID
            };

            // text changes will generally have afterID and beforeID, but we make
            // special note if it's the first child.
            if (textAfterID) {
                newEdit.afterID = textAfterID;
            } else {
                newEdit.firstChild = true;
            }
            newEdits.push(newEdit);

            // The text node is in the new tree, so we move to the next new tree item
            newIndex++;
        }
36053
protected void appendElement(StringBuilder sb, Element aNode) {
        sb.append("<")
            .append(aNode.getNodeName()).append("...")
            .append(">");
    }
1074388
public synchronized void addElement(@NonNull T element) {
        hashCached = false;
        this.elementsMap.put(element.getLabel(), element);
        this.elements.add(element);
    }
84850
def date_added(self, date_added):
        """"""
        self._group_data['dateAdded'] = self._utils.format_datetime(
            date_added, date_format='%Y-%m-%dT%H:%M:%SZ'
        )
575503
protected void putElement(Ehcache cache, Element element) {
        final Set<CacheEntryTag> tags = this.getTags(element);

        // Check if the key is tagged
        if (tags != null && !tags.isEmpty()) {
            final String cacheName = cache.getName();
            final Object key = element.getObjectKey();
            final LoadingCache<CacheEntryTag, Set<Object>> cacheKeys =
                    taggedCacheKeys.getUnchecked(cacheName);

            logger.debug("Tracking {} tags in cache {} for key {}", tags.size(), cacheName, key);

            // Add all the tags to the tracking map
            for (final CacheEntryTag tag : tags) {
                // Record that this tag type is stored in this cache
                final String tagType = tag.getTagType();
                final Set<Ehcache> caches = taggedCaches.getUnchecked(tagType);
                caches.add(cache);

                // Record the tag->key association
                final Set<Object> taggedKeys = cacheKeys.getUnchecked(tag);
                taggedKeys.add(key);
            }
        }
    }
289703
private void addLastOfType() {
		for (Node node : nodes) {
			Index index = helper.getIndexInParent(node, true);
			if (index.index == (index.size-1))
				result.add(node);
		}
	}