org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/provisional/ModelDelta.java - platform/eclipse.platform.debug - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2005, 2013 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
  *  which accompanies this distribution, and is available at
  *  https://www.eclipse.org/legal/epl-2.0/
  *
  *  SPDX-License-Identifier: EPL-2.0
  *
  *  Contributors:
  *     IBM Corporation - initial API and implementation
  *     Wind River Systems - Fix for viewer state save/restore [188704]
  *******************************************************************************/
 package org.eclipse.debug.internal.ui.viewers.model.provisional;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * A model delta. Used to create model deltas.
  * <p>
  * Clients may instantiate this class; not intended to be sub-classed.
  * </p>
  * @see IModelDelta
  * @since 3.2
  */
 public class ModelDelta implements IModelDelta {

 	private IModelDelta fParent;
 	private Object fElement;
 	private int fFlags;
 	private ModelDelta[] fNodes = EMPTY_NODES;
 	private List<ModelDelta> fNodesList;
 	// TODO this is not good, we are mixing a delta with an array of deltas
 	private Map<Object, Object> fNodesMap;
 	private Object fReplacement;
 	private int fIndex;
 	private int fChildCount;
 	private static final ModelDelta[] EMPTY_NODES = new ModelDelta[0];

 	/**
 	 * Constructs a new delta for the given element.
 	 *
 	 * @param element model element
 	 * @param flags change flags
 	 */
 	public ModelDelta(Object element, int flags) {
 		fElement = element;
 		fFlags = flags;
 		fIndex = -1;
 		fChildCount = -1;
 	}

 	/**
 	 * Constructs a new delta for the given element to be replaced
 	 * with the specified replacement element.
 	 *
 	 * @param element model element
 	 * @param replacement replacement element
 	 * @param flags change flags
 	 */
 	public ModelDelta(Object element, Object replacement, int flags) {
 		this(element, flags);
 		fReplacement = replacement;
 	}

 	/**
 	 * Constructs a new delta for the given element to be inserted at
 	 * the specified index.
 	 *
 	 * @param element model element
 	 * @param index insertion position
 	 * @param flags change flags
 	 */
 	public ModelDelta(Object element, int index, int flags) {
 		this(element, flags);
 		fIndex = index;
 	}

 	/**
 	 * Constructs a new delta for the given element at the specified index
 	 * relative to its parent with the given number of children.
 	 *
 	 * @param element model element
 	 * @param index insertion position
 	 * @param flags change flags
 	 * @param childCount number of children this node has
 	 */
 	public ModelDelta(Object element, int index, int flags, int childCount) {
 		this(element, index, flags);
 		fChildCount = childCount;
 	}

 	@Override
 	public Object getElement() {
 		return fElement;
 	}

 	@Override
 	public int getFlags() {
 		return fFlags;
 	}

 	/**
 	 * Adds a child node to this delta with the given element and change flags,
 	 * and returns the child delta.
 	 *
 	 * @param element child element to add
 	 * @param flags change flags for child
 	 * @return newly created child delta
 	 */
 	public ModelDelta addNode(Object element, int flags) {
 		ModelDelta node = new ModelDelta(element, flags);
 		node.setParent(this);
 		addDelta(node);
 		return node;
 	}

 	/**
 	 * Returns the child delta for the given element, or <code>null</code> if none.
 	 *
 	 * @param element child element
 	 * @return corresponding delta node, or <code>null</code>
 	 */
 	public ModelDelta getChildDelta(Object element) {
 		if (fNodesMap == null) {
 			mapNodes();
 		}
 		Object nodeOrNodes = fNodesMap.get(element);
 		if (nodeOrNodes instanceof ModelDelta) {
 			return (ModelDelta)nodeOrNodes;
 		} else if (nodeOrNodes instanceof ModelDelta[]) {
 			return ((ModelDelta[])nodeOrNodes)[0];
 		}
 		return null;
 	}

 	/**
 	 * Returns the child delta for the given element and index, or <code>null</code> if none.
 	 *
 	 * @param element Element of the child delta to find
 	 * @param index Index of the child delta to find.
 	 * @return corresponding delta node, or <code>null</code>
 	 *
 	 * @since 3.8
 	 */
 	public ModelDelta getChildDelta(Object element, int index) {
 		if (fNodesMap == null) {
 			mapNodes();
 		}
 		Object nodeOrNodes = fNodesMap.get(element);
 		if (nodeOrNodes instanceof ModelDelta) {
 			ModelDelta node = (ModelDelta)nodeOrNodes;
 			if (index == node.getIndex()) {
 				return node;
 			}
 		} else if (nodeOrNodes instanceof ModelDelta[]) {
 			ModelDelta[] nodes = (ModelDelta[])nodeOrNodes;
 			for (int i = 0; i < nodes.length; i++) {
 				if (index == nodes[i].getIndex()) {
 					return nodes[i];
 				}
 			}
 		}
 		return null;
 	}

 	private void mapNodes() {
 		if (fNodesList == null) {
 			fNodesMap = new HashMap<>(1);
 			return;
 		}
 		// Create a map with capacity for all child nodes.
 		fNodesMap = new HashMap<>(fNodesList.size() * 4 / 3);
 		for (int i = 0; i < fNodesList.size(); i++) {
 			mapNode( fNodesList.get(i) );
 		}
 	}

 	private void mapNode(ModelDelta node) {
 		Object oldValue = fNodesMap.put(node.getElement(), node);
 		if (oldValue instanceof ModelDelta) {
 			// Edge case: already a node for given element was added.
 			ModelDelta[] nodes = new ModelDelta[] { (ModelDelta)oldValue, node };
 			fNodesMap.put(node.getElement(), nodes);
 		} else if (oldValue instanceof ModelDelta[]) {
 			// Even more remote case: multiple delta nodes for the same element were already added
 			ModelDelta[] oldNodes = (ModelDelta[])oldValue;
 			ModelDelta[] newNodes = new ModelDelta[oldNodes.length + 1];
 			System.arraycopy(oldNodes, 0, newNodes, 0, oldNodes.length);
 			newNodes[newNodes.length - 1] = node;
 			fNodesMap.put(node.getElement(), newNodes);
 		}
 	}


 	/**
 	 * Adds a child node to this delta to replace the given element with the
 	 * specified replacement element and change flags, and returns the
 	 * newly created child delta.
 	 *
 	 * @param element child element to add to this delta
 	 * @param replacement replacement element for the child element
 	 * @param flags change flags
 	 * @return newly created child delta
 	 */
 	public ModelDelta addNode(Object element, Object replacement, int flags) {
 		ModelDelta node = new ModelDelta(element, replacement, flags);
 		node.setParent(this);
 		addDelta(node);
 		return node;
 	}

 	/**
 	 * Adds a child delta to this delta to insert the specified element at
 	 * the given index, and returns the newly created child delta.
 	 *
 	 * @param element child element in insert
 	 * @param index index of insertion
 	 * @param flags change flags
 	 * @return newly created child delta
 	 */
 	public ModelDelta addNode(Object element, int index, int flags) {
 		ModelDelta node = new ModelDelta(element, index, flags);
 		node.setParent(this);
 		addDelta(node);
 		return node;
 	}

 	/**
 	 * Adds a child delta to this delta at the specified index with the
 	 * given number of children, and returns the newly created child delta.
 	 *
 	 * @param element child element in insert
 	 * @param index index of the element relative to parent
 	 * @param flags change flags
 	 * @param numChildren the number of children the element has
 	 * @return newly created child delta
 	 */
 	public ModelDelta addNode(Object element, int index, int flags, int numChildren) {
 		ModelDelta node = new ModelDelta(element, index, flags, numChildren);
 		node.setParent(this);
 		addDelta(node);
 		return node;
 	}

 	/**
 	 * Sets the parent delta of this delta
 	 *
 	 * @param node parent delta
 	 */
 	void setParent(ModelDelta node) {
 		fParent = node;
 	}

 	@Override
 	public IModelDelta getParentDelta() {
 		return fParent;
 	}

 	@Override
 	public Object getReplacementElement() {
 		return fReplacement;
 	}

 	@Override
 	public int getIndex() {
 		return fIndex;
 	}

 	@Override
 	public IModelDelta[] getChildDeltas() {
 		if (fNodes == null) {
 			fNodes = fNodesList.toArray(new ModelDelta[fNodesList.size()]);
 		}
 		return fNodes;
 	}

 	private void addDelta(ModelDelta delta) {
 		if (fNodesList == null) {
 			fNodesList = new ArrayList<>(4);
 		}
 		fNodesList.add(delta);
 		fNodes = null;
 		if (fNodesMap != null) {
 			mapNode(delta);
 		}
 	}

 	@Override
 	public String toString() {
 		StringBuffer buf = new StringBuffer();
 		buf.append("Model Delta Start\n"); //$NON-NLS-1$
 		appendDetail("  ", buf, this); //$NON-NLS-1$
 		buf.append("Model Delta End\n"); //$NON-NLS-1$
 		return buf.toString();
 	}

 	private void appendDetail(String indent, StringBuffer buf, IModelDelta delta) {
 		buf.append(indent);
 		buf.append("Element: "); //$NON-NLS-1$
 		buf.append(delta.getElement());
 		buf.append('\n');
 		buf.append(indent);
 		buf.append("    Flags: "); //$NON-NLS-1$
 		int flags = delta.getFlags();
 		if (flags == 0) {
 			buf.append("NO_CHANGE"); //$NON-NLS-1$
 		} else {
 			if ((flags & IModelDelta.ADDED) > 0) {
 				buf.append("ADDED | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.CONTENT) > 0) {
 				buf.append("CONTENT | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.COLLAPSE) > 0) {
 				buf.append("COLLAPSE | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.EXPAND) > 0) {
 				buf.append("EXPAND | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.INSERTED) > 0) {
 				buf.append("INSERTED | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.REMOVED) > 0) {
 				buf.append("REMOVED | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.REPLACED) > 0) {
 				buf.append("REPLACED | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.SELECT) > 0) {
 				buf.append("SELECT | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.STATE) > 0) {
 				buf.append("STATE | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.INSTALL) > 0) {
 				buf.append("INSTALL | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.UNINSTALL) > 0) {
 				buf.append("UNINSTALL | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.REVEAL) > 0) {
 				buf.append("REVEAL | "); //$NON-NLS-1$
 			}
 			if ((flags & IModelDelta.FORCE) > 0) {
 				buf.append("FORCE | "); //$NON-NLS-1$
 			}

 		}
 		buf.append('\n');
 		buf.append(indent);
 		buf.append("    Index: "); //$NON-NLS-1$
 		buf.append(delta.getIndex());
 		buf.append(" Child Count: "); //$NON-NLS-1$
 		buf.append(delta.getChildCount());
 		buf.append('\n');
 		IModelDelta[] nodes = delta.getChildDeltas();
 		for (int i = 0; i < nodes.length; i++) {
 			appendDetail(indent + "  ", buf, nodes[i]); //$NON-NLS-1$
 		}
 	}

 	@Override
 	public int getChildCount() {
 		return fChildCount;
 	}

 	@Override
 	public void accept(IModelDeltaVisitor visitor) {
 		doAccept(visitor, 0);
 	}

 	protected void doAccept(IModelDeltaVisitor visitor, int depth) {
 		if (visitor.visit(this, depth)) {
 			IModelDelta[] childDeltas = getChildDeltas();
 			for (int i = 0; i < childDeltas.length; i++) {
 				((ModelDelta)childDeltas[i]).doAccept(visitor, depth+1);
 			}
 		}
 	}

 	/**
 	 * Sets this delta's element
 	 *
 	 * @param element element to set
 	 */
 	public void setElement(Object element) {
 		fElement = element;
 	}

 	/**
 	 * Sets this delta's flags.
 	 *
 	 * @param flagsnew flags to set
 	 */
 	public void setFlags(int flags) {
 		fFlags = flags;
 	}

 	/**
 	 * Sets this delta's index
 	 *
 	 * @param index new index to set
 	 * @since 3.6
 	 */
 	public void setIndex(int index) {
 		fIndex = index;
 	}

 	/**
 	 * Sets this delta's child count.
 	 *
 	 * @param count new child count to set
 	 */
 	public void setChildCount(int count) {
 		fChildCount = count;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2013 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Wind River Systems - Fix for viewer state save/restore [188704]
	*******************************************************************************/
	package org.eclipse.debug.internal.ui.viewers.model.provisional;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* A model delta. Used to create model deltas.
	* <p>
	* Clients may instantiate this class; not intended to be sub-classed.
	* </p>
	* @see IModelDelta
	* @since 3.2
	*/
	public class ModelDelta implements IModelDelta {

	private IModelDelta fParent;
	private Object fElement;
	private int fFlags;
	private ModelDelta[] fNodes = EMPTY_NODES;
	private List<ModelDelta> fNodesList;
	// TODO this is not good, we are mixing a delta with an array of deltas
	private Map<Object, Object> fNodesMap;
	private Object fReplacement;
	private int fIndex;
	private int fChildCount;
	private static final ModelDelta[] EMPTY_NODES = new ModelDelta[0];

	/**
	* Constructs a new delta for the given element.
	*
	* @param element model element
	* @param flags change flags
	*/
	public ModelDelta(Object element, int flags) {
	fElement = element;
	fFlags = flags;
	fIndex = -1;
	fChildCount = -1;
	}

	/**
	* Constructs a new delta for the given element to be replaced
	* with the specified replacement element.
	*
	* @param element model element
	* @param replacement replacement element
	* @param flags change flags
	*/
	public ModelDelta(Object element, Object replacement, int flags) {
	this(element, flags);
	fReplacement = replacement;
	}

	/**
	* Constructs a new delta for the given element to be inserted at
	* the specified index.
	*
	* @param element model element
	* @param index insertion position
	* @param flags change flags
	*/
	public ModelDelta(Object element, int index, int flags) {
	this(element, flags);
	fIndex = index;
	}

	/**
	* Constructs a new delta for the given element at the specified index
	* relative to its parent with the given number of children.
	*
	* @param element model element
	* @param index insertion position
	* @param flags change flags
	* @param childCount number of children this node has
	*/
	public ModelDelta(Object element, int index, int flags, int childCount) {
	this(element, index, flags);
	fChildCount = childCount;
	}

	@Override
	public Object getElement() {
	return fElement;
	}

	@Override
	public int getFlags() {
	return fFlags;
	}

	/**
	* Adds a child node to this delta with the given element and change flags,
	* and returns the child delta.
	*
	* @param element child element to add
	* @param flags change flags for child
	* @return newly created child delta
	*/
	public ModelDelta addNode(Object element, int flags) {
	ModelDelta node = new ModelDelta(element, flags);
	node.setParent(this);
	addDelta(node);
	return node;
	}

	/**
	* Returns the child delta for the given element, or <code>null</code> if none.
	*
	* @param element child element
	* @return corresponding delta node, or <code>null</code>
	*/
	public ModelDelta getChildDelta(Object element) {
	if (fNodesMap == null) {
	mapNodes();
	}
	Object nodeOrNodes = fNodesMap.get(element);
	if (nodeOrNodes instanceof ModelDelta) {
	return (ModelDelta)nodeOrNodes;
	} else if (nodeOrNodes instanceof ModelDelta[]) {
	return ((ModelDelta[])nodeOrNodes)[0];
	}
	return null;
	}

	/**
	* Returns the child delta for the given element and index, or <code>null</code> if none.
	*
	* @param element Element of the child delta to find
	* @param index Index of the child delta to find.
	* @return corresponding delta node, or <code>null</code>
	*
	* @since 3.8
	*/
	public ModelDelta getChildDelta(Object element, int index) {
	if (fNodesMap == null) {
	mapNodes();
	}
	Object nodeOrNodes = fNodesMap.get(element);
	if (nodeOrNodes instanceof ModelDelta) {
	ModelDelta node = (ModelDelta)nodeOrNodes;
	if (index == node.getIndex()) {
	return node;
	}
	} else if (nodeOrNodes instanceof ModelDelta[]) {
	ModelDelta[] nodes = (ModelDelta[])nodeOrNodes;
	for (int i = 0; i < nodes.length; i++) {
	if (index == nodes[i].getIndex()) {
	return nodes[i];
	}
	}
	}
	return null;
	}

	private void mapNodes() {
	if (fNodesList == null) {
	fNodesMap = new HashMap<>(1);
	return;
	}
	// Create a map with capacity for all child nodes.
	fNodesMap = new HashMap<>(fNodesList.size() * 4 / 3);
	for (int i = 0; i < fNodesList.size(); i++) {
	mapNode( fNodesList.get(i) );
	}
	}

	private void mapNode(ModelDelta node) {
	Object oldValue = fNodesMap.put(node.getElement(), node);
	if (oldValue instanceof ModelDelta) {
	// Edge case: already a node for given element was added.
	ModelDelta[] nodes = new ModelDelta[] { (ModelDelta)oldValue, node };
	fNodesMap.put(node.getElement(), nodes);
	} else if (oldValue instanceof ModelDelta[]) {
	// Even more remote case: multiple delta nodes for the same element were already added
	ModelDelta[] oldNodes = (ModelDelta[])oldValue;
	ModelDelta[] newNodes = new ModelDelta[oldNodes.length + 1];
	System.arraycopy(oldNodes, 0, newNodes, 0, oldNodes.length);
	newNodes[newNodes.length - 1] = node;
	fNodesMap.put(node.getElement(), newNodes);
	}
	}


	/**
	* Adds a child node to this delta to replace the given element with the
	* specified replacement element and change flags, and returns the
	* newly created child delta.
	*
	* @param element child element to add to this delta
	* @param replacement replacement element for the child element
	* @param flags change flags
	* @return newly created child delta
	*/
	public ModelDelta addNode(Object element, Object replacement, int flags) {
	ModelDelta node = new ModelDelta(element, replacement, flags);
	node.setParent(this);
	addDelta(node);
	return node;
	}

	/**
	* Adds a child delta to this delta to insert the specified element at
	* the given index, and returns the newly created child delta.
	*
	* @param element child element in insert
	* @param index index of insertion
	* @param flags change flags
	* @return newly created child delta
	*/
	public ModelDelta addNode(Object element, int index, int flags) {
	ModelDelta node = new ModelDelta(element, index, flags);
	node.setParent(this);
	addDelta(node);
	return node;
	}

	/**
	* Adds a child delta to this delta at the specified index with the
	* given number of children, and returns the newly created child delta.
	*
	* @param element child element in insert
	* @param index index of the element relative to parent
	* @param flags change flags
	* @param numChildren the number of children the element has
	* @return newly created child delta
	*/
	public ModelDelta addNode(Object element, int index, int flags, int numChildren) {
	ModelDelta node = new ModelDelta(element, index, flags, numChildren);
	node.setParent(this);
	addDelta(node);
	return node;
	}

	/**
	* Sets the parent delta of this delta
	*
	* @param node parent delta
	*/
	void setParent(ModelDelta node) {
	fParent = node;
	}

	@Override
	public IModelDelta getParentDelta() {
	return fParent;
	}

	@Override
	public Object getReplacementElement() {
	return fReplacement;
	}

	@Override
	public int getIndex() {
	return fIndex;
	}

	@Override
	public IModelDelta[] getChildDeltas() {
	if (fNodes == null) {
	fNodes = fNodesList.toArray(new ModelDelta[fNodesList.size()]);
	}
	return fNodes;
	}

	private void addDelta(ModelDelta delta) {
	if (fNodesList == null) {
	fNodesList = new ArrayList<>(4);
	}
	fNodesList.add(delta);
	fNodes = null;
	if (fNodesMap != null) {
	mapNode(delta);
	}
	}

	@Override
	public String toString() {
	StringBuffer buf = new StringBuffer();
	buf.append("Model Delta Start\n"); //$NON-NLS-1$
	appendDetail(" ", buf, this); //$NON-NLS-1$
	buf.append("Model Delta End\n"); //$NON-NLS-1$
	return buf.toString();
	}

	private void appendDetail(String indent, StringBuffer buf, IModelDelta delta) {
	buf.append(indent);
	buf.append("Element: "); //$NON-NLS-1$
	buf.append(delta.getElement());
	buf.append('\n');
	buf.append(indent);
	buf.append(" Flags: "); //$NON-NLS-1$
	int flags = delta.getFlags();
	if (flags == 0) {
	buf.append("NO_CHANGE"); //$NON-NLS-1$
	} else {
	if ((flags & IModelDelta.ADDED) > 0) {
	buf.append("ADDED \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.CONTENT) > 0) {
	buf.append("CONTENT \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.COLLAPSE) > 0) {
	buf.append("COLLAPSE \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.EXPAND) > 0) {
	buf.append("EXPAND \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.INSERTED) > 0) {
	buf.append("INSERTED \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.REMOVED) > 0) {
	buf.append("REMOVED \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.REPLACED) > 0) {
	buf.append("REPLACED \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.SELECT) > 0) {
	buf.append("SELECT \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.STATE) > 0) {
	buf.append("STATE \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.INSTALL) > 0) {
	buf.append("INSTALL \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.UNINSTALL) > 0) {
	buf.append("UNINSTALL \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.REVEAL) > 0) {
	buf.append("REVEAL \| "); //$NON-NLS-1$
	}
	if ((flags & IModelDelta.FORCE) > 0) {
	buf.append("FORCE \| "); //$NON-NLS-1$
	}

	}
	buf.append('\n');
	buf.append(indent);
	buf.append(" Index: "); //$NON-NLS-1$
	buf.append(delta.getIndex());
	buf.append(" Child Count: "); //$NON-NLS-1$
	buf.append(delta.getChildCount());
	buf.append('\n');
	IModelDelta[] nodes = delta.getChildDeltas();
	for (int i = 0; i < nodes.length; i++) {
	appendDetail(indent + " ", buf, nodes[i]); //$NON-NLS-1$
	}
	}

	@Override
	public int getChildCount() {
	return fChildCount;
	}

	@Override
	public void accept(IModelDeltaVisitor visitor) {
	doAccept(visitor, 0);
	}

	protected void doAccept(IModelDeltaVisitor visitor, int depth) {
	if (visitor.visit(this, depth)) {
	IModelDelta[] childDeltas = getChildDeltas();
	for (int i = 0; i < childDeltas.length; i++) {
	((ModelDelta)childDeltas[i]).doAccept(visitor, depth+1);
	}
	}
	}

	/**
	* Sets this delta's element
	*
	* @param element element to set
	*/
	public void setElement(Object element) {
	fElement = element;
	}

	/**
	* Sets this delta's flags.
	*
	* @param flagsnew flags to set
	*/
	public void setFlags(int flags) {
	fFlags = flags;
	}

	/**
	* Sets this delta's index
	*
	* @param index new index to set
	* @since 3.6
	*/
	public void setIndex(int index) {
	fIndex = index;
	}

	/**
	* Sets this delta's child count.
	*
	* @param count new child count to set
	*/
	public void setChildCount(int count) {
	fChildCount = count;
	}

	}