| /******************************************************************************* |
| * Copyright (c) 2008-2011 Sonatype, Inc. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Sonatype, Inc. - initial API and implementation |
| * Andrew Eisenberg - Work on Bug 350414 |
| *******************************************************************************/ |
| |
| package org.eclipse.m2e.core.ui.internal.editing; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| import org.w3c.dom.Text; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jface.text.DocumentRewriteSession; |
| import org.eclipse.jface.text.DocumentRewriteSessionType; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IDocumentExtension4; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; |
| import org.eclipse.wst.sse.core.internal.undo.IStructuredTextUndoManager; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; |
| import org.eclipse.wst.xml.core.internal.provisional.format.FormatProcessorXML; |
| |
| |
| /** |
| * this class contains tools for editing the pom files using dom tree operations. |
| * |
| * @author mkleint |
| */ |
| @SuppressWarnings("restriction") |
| public class PomEdits { |
| |
| public static final String NAMESPACE = "http://maven.apache.org/POM/4.0.0"; //$NON-NLS-1$ |
| |
| public static final String NAMESPACE_LOCATION = "http://maven.apache.org/xsd/maven-4.0.0.xsd"; //$NON-NLS-1$ |
| |
| public static final String PROJECT = "project"; //$NON-NLS-1$ |
| |
| public static final String MODEL_VERSION = "modelVersion"; //$NON-NLS-1$ |
| |
| public static final String MODEL_VERSION_VALUE = "4.0.0"; //$NON-NLS-1$ |
| |
| public static final String DEPENDENCIES = "dependencies"; //$NON-NLS-1$ |
| |
| public static final String GROUP_ID = "groupId";//$NON-NLS-1$ |
| |
| public static final String ARTIFACT_ID = "artifactId"; //$NON-NLS-1$ |
| |
| public static final String DEPENDENCY = "dependency"; //$NON-NLS-1$ |
| |
| public static final String DEPENDENCY_MANAGEMENT = "dependencyManagement"; //$NON-NLS-1$ |
| |
| public static final String EXCLUSIONS = "exclusions"; //$NON-NLS-1$ |
| |
| public static final String EXCLUSION = "exclusion"; //$NON-NLS-1$ |
| |
| public static final String VERSION = "version"; //$NON-NLS-1$ |
| |
| public static final String PLUGIN = "plugin"; //$NON-NLS-1$ |
| |
| public static final String CONFIGURATION = "configuration";//$NON-NLS-1$ |
| |
| public static final String PLUGINS = "plugins";//$NON-NLS-1$ |
| |
| public static final String PLUGIN_MANAGEMENT = "pluginManagement";//$NON-NLS-1$ |
| |
| public static final String BUILD = "build";//$NON-NLS-1$ |
| |
| public static final String PARENT = "parent";//$NON-NLS-1$ |
| |
| public static final String RELATIVE_PATH = "relativePath";//$NON-NLS-1$ |
| |
| public static final String TYPE = "type";//$NON-NLS-1$ |
| |
| public static final String CLASSIFIER = "classifier";//$NON-NLS-1$ |
| |
| public static final String OPTIONAL = "optional";//$NON-NLS-1$ |
| |
| public static final String SCOPE = "scope";//$NON-NLS-1$ |
| |
| public static final String MODULES = "modules";//$NON-NLS-1$ |
| |
| public static final String MODULE = "module";//$NON-NLS-1$ |
| |
| public static final String PROFILE = "profile";//$NON-NLS-1$ |
| |
| public static final String ID = "id";//$NON-NLS-1$ |
| |
| public static final String NAME = "name"; //$NON-NLS-1$ |
| |
| public static final String URL = "url";//$NON-NLS-1$ |
| |
| public static final String DESCRIPTION = "description";//$NON-NLS-1$ |
| |
| public static final String INCEPTION_YEAR = "inceptionYear";//$NON-NLS-1$ |
| |
| public static final String ORGANIZATION = "organization"; //$NON-NLS-1$ |
| |
| public static final String SCM = "scm"; //$NON-NLS-1$ |
| |
| public static final String CONNECTION = "connection";//$NON-NLS-1$ |
| |
| public static final String DEV_CONNECTION = "developerConnection";//$NON-NLS-1$ |
| |
| public static final String TAG = "tag";//$NON-NLS-1$ |
| |
| public static final String ISSUE_MANAGEMENT = "issueManagement"; //$NON-NLS-1$ |
| |
| public static final String SYSTEM = "system"; //$NON-NLS-1$ |
| |
| public static final String SYSTEM_PATH = "systemPath"; //$NON-NLS-1$ |
| |
| public static final String CI_MANAGEMENT = "ciManagement"; //$NON-NLS-1$ |
| |
| public static final String PACKAGING = "packaging"; //$NON-NLS-1$ |
| |
| public static final String PROPERTIES = "properties"; //$NON-NLS-1$ |
| |
| public static final String EXTENSION = "extension"; //$NON-NLS-1$ |
| |
| public static final String EXTENSIONS = "extensions"; //$NON-NLS-1$ |
| |
| public static final String PROFILES = "profiles";//$NON-NLS-1$ |
| |
| public static final String EXECUTIONS = "executions"; //$NON-NLS-1$ |
| |
| public static final String EXECUTION = "execution";//$NON-NLS-1$ |
| |
| public static final String GOAL = "goal";//$NON-NLS-1$ |
| |
| public static final String GOALS = "goals";//$NON-NLS-1$ |
| |
| public static Element findChild(Element parent, String name) { |
| if(parent == null) { |
| return null; |
| } |
| NodeList rootList = parent.getChildNodes(); |
| for(int i = 0; i < rootList.getLength(); i++ ) { |
| Node nd = rootList.item(i); |
| if(nd instanceof Element) { |
| Element el = (Element) nd; |
| if(name.equals(el.getNodeName())) { |
| return el; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static List<Element> findChilds(Element parent, String name) { |
| List<Element> toRet = new ArrayList<Element>(); |
| if(parent != null) { |
| NodeList rootList = parent.getChildNodes(); |
| for(int i = 0; i < rootList.getLength(); i++ ) { |
| Node nd = rootList.item(i); |
| if(nd instanceof Element) { |
| Element el = (Element) nd; |
| if(name.equals(el.getNodeName())) { |
| toRet.add(el); |
| } |
| } |
| } |
| } |
| return toRet; |
| } |
| |
| public static String getTextValue(Node element) { |
| if(element == null) |
| return null; |
| StringBuffer buff = new StringBuffer(); |
| NodeList list = element.getChildNodes(); |
| for(int i = 0; i < list.getLength(); i++ ) { |
| Node child = list.item(i); |
| if(child instanceof Text) { |
| Text text = (Text) child; |
| buff.append(text.getData().trim()); //352416 the value is trimmed because of the multiline values |
| //that get trimmed by maven itself as well, any comparison to resolved model needs to do the trimming |
| // or risks false negative results. |
| } |
| } |
| return buff.toString(); |
| } |
| |
| /** |
| * finds exactly one (first) occurence of child element with the given name (eg. dependency) that fulfills conditions |
| * expressed by the Matchers (eg. groupId/artifactId match) |
| * |
| * @param parent |
| * @param name |
| * @param matchers |
| * @return |
| */ |
| public static Element findChild(Element parent, String name, Matcher... matchers) { |
| OUTTER: for(Element el : findChilds(parent, name)) { |
| for(Matcher match : matchers) { |
| if(!match.matches(el)) { |
| continue OUTTER; |
| } |
| } |
| return el; |
| } |
| return null; |
| } |
| |
| /** |
| * helper method, creates a subelement with text embedded. does not format the result. primarily to be used in cases |
| * like <code><goals><goal>xxx</goal></goals></code> |
| * |
| * @param parent |
| * @param name |
| * @param value |
| * @return |
| */ |
| public static Element createElementWithText(Element parent, String name, String value) { |
| Document doc = parent.getOwnerDocument(); |
| Element newElement = doc.createElement(name); |
| parent.appendChild(newElement); |
| newElement.appendChild(doc.createTextNode(value)); |
| return newElement; |
| } |
| |
| /** |
| * helper method, creates a subelement, does not format result. |
| * |
| * @param parent the parent element |
| * @param name the name of the new element |
| * @return the created element |
| */ |
| public static Element createElement(Element parent, String name) { |
| Document doc = parent.getOwnerDocument(); |
| Element newElement = doc.createElement(name); |
| parent.appendChild(newElement); |
| return newElement; |
| } |
| |
| /** |
| * sets text value to the given element. any existing text children are removed and replaced by this new one. |
| * |
| * @param element |
| * @param value |
| */ |
| public static void setText(Element element, String value) { |
| NodeList list = element.getChildNodes(); |
| List<Node> toRemove = new ArrayList<Node>(); |
| for(int i = 0; i < list.getLength(); i++ ) { |
| Node child = list.item(i); |
| if(child instanceof Text) { |
| toRemove.add(child); |
| } |
| } |
| for(Node rm : toRemove) { |
| element.removeChild(rm); |
| } |
| Document doc = element.getOwnerDocument(); |
| element.appendChild(doc.createTextNode(value)); |
| } |
| |
| /** |
| * unlike the findChild() equivalent, this one creates the element if not present and returns it. Therefore it shall |
| * only be invoked within the PomEdits.Operation |
| * |
| * @param parent |
| * @param names chain of element names to find/create |
| * @return |
| */ |
| public static Element getChild(Element parent, String... names) { |
| Element toFormat = null; |
| Element toRet = null; |
| if(names.length == 0) { |
| throw new IllegalArgumentException("At least one child name has to be specified"); |
| } |
| for(String name : names) { |
| toRet = findChild(parent, name); |
| if(toRet == null) { |
| toRet = parent.getOwnerDocument().createElement(name); |
| parent.appendChild(toRet); |
| if(toFormat == null) { |
| toFormat = toRet; |
| } |
| } |
| parent = toRet; |
| } |
| if(toFormat != null) { |
| format(toFormat); |
| } |
| return toRet; |
| } |
| |
| /** |
| * proper remove of a child element |
| */ |
| public static void removeChild(Element parent, Element child) { |
| if(child != null) { |
| Node prev = child.getPreviousSibling(); |
| if(prev instanceof Text) { |
| Text txt = (Text) prev; |
| int lastnewline = getLastEolIndex(txt.getData()); |
| if(lastnewline >= 0) { |
| txt.setData(txt.getData().substring(0, lastnewline)); |
| } |
| } |
| parent.removeChild(child); |
| } |
| } |
| |
| private static int getLastEolIndex(String s) { |
| if(s == null || s.length() == 0) { |
| return -1; |
| } |
| for(int i = s.length() - 1; i >= 0; i-- ) { |
| char c = s.charAt(i); |
| if(c == '\r') { |
| return i; |
| } |
| if(c == '\n') { |
| if(i > 0 && s.charAt(i - 1) == '\r') { |
| return i - 1; |
| } |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * remove the current element if it doesn't contain any sublements, useful for lists etc, works recursively removing |
| * all parents up that don't have any children elements. |
| * |
| * @param el |
| */ |
| public static void removeIfNoChildElement(Element el) { |
| NodeList nl = el.getChildNodes(); |
| boolean hasChilds = false; |
| for(int i = 0; i < nl.getLength(); i++ ) { |
| Node child = nl.item(i); |
| if(child instanceof Element) { |
| hasChilds = true; |
| } |
| } |
| if(!hasChilds) { |
| Node parent = el.getParentNode(); |
| if(parent != null && parent instanceof Element) { |
| removeChild((Element) parent, el); |
| removeIfNoChildElement((Element) parent); |
| } |
| } |
| } |
| |
| public static Element insertAt(Element newElement, int offset) { |
| Document doc = newElement.getOwnerDocument(); |
| if(doc instanceof IDOMDocument) { |
| IDOMDocument domDoc = (IDOMDocument) doc; |
| IndexedRegion ir = domDoc.getModel().getIndexedRegion(offset); |
| Node parent = ((Node) ir).getParentNode(); |
| if(ir instanceof Text) { |
| Text txt = (Text) ir; |
| String data = txt.getData(); |
| int dataSplitIndex = offset - ir.getStartOffset(); |
| String beforeText = data.substring(0, dataSplitIndex); |
| String afterText = data.substring(dataSplitIndex); |
| Text after = doc.createTextNode(afterText); |
| Text before = doc.createTextNode(beforeText); |
| parent.replaceChild(after, txt); |
| parent.insertBefore(newElement, after); |
| parent.insertBefore(before, newElement); |
| } else if(ir instanceof Element) { |
| if(ir.getStartOffset() == offset) { |
| // caret is before the tag, not within its bounds |
| parent.insertBefore(newElement, (Element) ir); |
| } else { |
| ((Element) ir).appendChild(newElement); |
| } |
| } else { |
| throw new IllegalArgumentException(); |
| } |
| } else { |
| throw new IllegalArgumentException(); |
| } |
| return newElement; |
| } |
| |
| /** |
| * finds the element at offset, if other type of node at offset, will return it's parent element (if any) |
| * |
| * @param doc |
| * @param offset |
| * @return |
| */ |
| public static Element elementAtOffset(Document doc, int offset) { |
| if(doc instanceof IDOMDocument) { |
| IDOMDocument domDoc = (IDOMDocument) doc; |
| IndexedRegion ir = domDoc.getModel().getIndexedRegion(offset); |
| if(ir instanceof Element) { |
| Element elem = (Element) ir; |
| if(ir.getStartOffset() == offset) { |
| // caret is before the tag, not within its bounds |
| elem = (Element) elem.getParentNode(); |
| } |
| return elem; |
| } |
| Node parent = ((Node) ir).getParentNode(); |
| if(parent instanceof Element) { |
| return (Element) parent; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * formats the node (and content). please make sure to only format the node you have created.. |
| * |
| * @param newNode |
| */ |
| public static void format(Node newNode) { |
| Node parentNode = newNode.getParentNode(); |
| if(parentNode != null && newNode.equals(parentNode.getLastChild())) { |
| //add a new line to get the newly generated content correctly formatted. |
| Document ownerDocument; |
| if(parentNode instanceof Document) { |
| ownerDocument = (Document) parentNode; |
| } else { |
| ownerDocument = parentNode.getOwnerDocument(); |
| } |
| parentNode.appendChild(ownerDocument.createTextNode("\n")); //$NON-NLS-1$ |
| } |
| FormatProcessorXML formatProcessor = new FormatProcessorXML(); |
| //ignore any line width settings, causes wrong formatting of <foo>bar</foo> |
| formatProcessor.getFormatPreferences().setLineWidth(2000); |
| formatProcessor.formatNode(newNode); |
| } |
| |
| /** |
| * performs an modifying operation on top the |
| * |
| * @param file |
| * @param operation |
| * @throws IOException |
| * @throws CoreException |
| */ |
| public static void performOnDOMDocument(PomEdits.OperationTuple... fileOperations) throws IOException, CoreException { |
| for(OperationTuple tuple : fileOperations) { |
| IDOMModel domModel = null; |
| //TODO we might want to attempt iterating opened editors and somehow initialize those |
| // that were not yet initialized. Then we could avoid saving a file that is actually opened, but was never used so far (after restart) |
| try { |
| DocumentRewriteSession session = null; |
| IStructuredTextUndoManager undo = null; |
| if(tuple.isReadOnly()) { |
| domModel = (IDOMModel) StructuredModelManager.getModelManager().getExistingModelForRead(tuple.getDocument()); |
| if(domModel == null) { |
| domModel = (IDOMModel) StructuredModelManager.getModelManager().getModelForRead( |
| (IStructuredDocument) tuple.getDocument()); |
| } |
| } else { |
| domModel = tuple.getModel() != null ? tuple.getModel() |
| : (tuple.getFile() != null ? (IDOMModel) StructuredModelManager.getModelManager().getModelForEdit( |
| tuple.getFile()) : (IDOMModel) StructuredModelManager.getModelManager().getExistingModelForEdit( |
| tuple.getDocument())); //existing shall be ok here.. |
| |
| //let the model know we make changes |
| domModel.aboutToChangeModel(); |
| undo = domModel.getStructuredDocument().getUndoManager(); |
| //let the document know we make changes |
| if(domModel.getStructuredDocument() instanceof IDocumentExtension4) { |
| IDocumentExtension4 ext4 = (IDocumentExtension4) domModel.getStructuredDocument(); |
| session = ext4.startRewriteSession(DocumentRewriteSessionType.UNRESTRICTED_SMALL); |
| } |
| undo.beginRecording(domModel); |
| |
| // fill with minimal pom content |
| Document doc = domModel.getDocument(); |
| if(doc.getDocumentElement() == null) { |
| |
| Node first = doc.getFirstChild(); |
| if(first == null || !(first instanceof ProcessingInstruction)) { |
| doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), first); //$NON-NLS-1$ //$NON-NLS-2$ |
| doc.insertBefore(doc.createTextNode("\n"), first); //$NON-NLS-1$ |
| } |
| |
| Element project = doc.createElement(PROJECT); |
| project.setAttribute("xmlns", NAMESPACE); //$NON-NLS-1$ |
| project.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); //$NON-NLS-1$ //$NON-NLS-2$ |
| project.setAttribute("xsi:schemaLocation", NAMESPACE + " " + NAMESPACE_LOCATION); //$NON-NLS-1$ //$NON-NLS-2$ |
| doc.appendChild(project); |
| |
| Element modelVersion = doc.createElement(MODEL_VERSION); |
| modelVersion.appendChild(doc.createTextNode(MODEL_VERSION_VALUE)); //$NON-NLS-1$ |
| project.appendChild(modelVersion); |
| format(project); |
| } |
| } |
| |
| try { |
| tuple.getOperation().process(domModel.getDocument()); |
| } finally { |
| if(!tuple.isReadOnly()) { |
| undo.endRecording(domModel); |
| if(session != null && domModel.getStructuredDocument() instanceof IDocumentExtension4) { |
| IDocumentExtension4 ext4 = (IDocumentExtension4) domModel.getStructuredDocument(); |
| ext4.stopRewriteSession(session); |
| } |
| domModel.changedModel(); |
| } |
| } |
| } finally { |
| if(domModel != null) { |
| if(tuple.isReadOnly()) { |
| domModel.releaseFromRead(); |
| } else if(domModel.getId() != null) { // id will be null for files outside of workspace |
| //for ducuments saving shall generally only happen when the model is not held elsewhere (eg. in opened view) |
| //for files, save always |
| if(tuple.isForceSave() || domModel.getReferenceCountForEdit() == 1) { |
| domModel.save(); |
| } |
| domModel.releaseFromEdit(); |
| } |
| } |
| } |
| } |
| } |
| |
| public static final class OperationTuple { |
| private final PomEdits.Operation operation; |
| |
| private final IFile file; |
| |
| private final IDocument document; |
| |
| private final IDOMModel model; |
| |
| private boolean readOnly = false; |
| |
| private boolean forceSave = false; |
| |
| /** |
| * operation on top of IFile is always saved |
| * |
| * @param file |
| * @param operation |
| */ |
| public OperationTuple(IFile file, PomEdits.Operation operation) { |
| assert file != null; |
| assert operation != null; |
| this.file = file; |
| this.operation = operation; |
| document = null; |
| model = null; |
| forceSave = true; |
| } |
| |
| /** |
| * operation on top of IDocument is only saved when noone else is editing the document. |
| * |
| * @param document |
| * @param operation |
| */ |
| public OperationTuple(IDocument document, PomEdits.Operation operation) { |
| this(document, operation, false); |
| } |
| |
| /** |
| * operation on top of IDocument is only saved when noone else is editing the document. |
| * |
| * @param document |
| * @param operation |
| * @param readonly operation that doesn't modify the content. Will only get the read, not edit model, up to the user |
| * of the code to ensure no edits happen |
| */ |
| public OperationTuple(IDocument document, PomEdits.Operation operation, boolean readOnly) { |
| assert operation != null; |
| this.document = document; |
| this.operation = operation; |
| file = null; |
| model = null; |
| this.readOnly = readOnly; |
| } |
| |
| /** |
| * only use for unmanaged models |
| * |
| * @param model |
| * @param operation |
| */ |
| public OperationTuple(IDOMModel model, PomEdits.Operation operation) { |
| assert model != null; |
| this.operation = operation; |
| this.model = model; |
| document = null; |
| file = null; |
| } |
| |
| /** |
| * force saving the document after performing the operation |
| */ |
| public void setForceSave() { |
| forceSave = true; |
| } |
| |
| public boolean isForceSave() { |
| return forceSave; |
| } |
| |
| /** |
| * @return Returns the readOnly. |
| */ |
| public boolean isReadOnly() { |
| return readOnly; |
| } |
| |
| public IFile getFile() { |
| return file; |
| } |
| |
| public PomEdits.Operation getOperation() { |
| return operation; |
| } |
| |
| public IDocument getDocument() { |
| return document; |
| } |
| |
| public IDOMModel getModel() { |
| return model; |
| } |
| |
| } |
| |
| /** |
| * operation to perform on top of the DOM document. see performOnDOMDocument() |
| * |
| * @author mkleint |
| */ |
| public static interface Operation { |
| void process(Document document); |
| } |
| |
| /** |
| * an Operation instance that aggregates multiple operations and performs then in given order. |
| * |
| * @author mkleint |
| */ |
| public static final class CompoundOperation implements Operation { |
| |
| private final Operation[] operations; |
| |
| public CompoundOperation(Operation... operations) { |
| this.operations = operations; |
| } |
| |
| public void process(Document document) { |
| for(Operation oper : operations) { |
| oper.process(document); |
| } |
| } |
| } |
| |
| /** |
| * an interface for identifying child elements that fulfill conditions expressed by the matcher. |
| * |
| * @author mkleint |
| */ |
| public static interface Matcher { |
| /** |
| * returns true if the given element matches the condition. |
| * |
| * @param child |
| * @return |
| */ |
| boolean matches(Element element); |
| } |
| |
| public static Matcher childEquals(final String elementName, final String matchingValue) { |
| return new Matcher() { |
| public boolean matches(Element child) { |
| String toMatch = PomEdits.getTextValue(PomEdits.findChild(child, elementName)); |
| return toMatch != null && toMatch.trim().equals(matchingValue); |
| } |
| }; |
| } |
| |
| public static Matcher textEquals(final String matchingValue) { |
| return new Matcher() { |
| public boolean matches(Element child) { |
| String toMatch = PomEdits.getTextValue(child); |
| return toMatch != null && toMatch.trim().equals(matchingValue); |
| } |
| }; |
| } |
| |
| public static Matcher childMissingOrEqual(final String elementName, final String matchingValue) { |
| return new Matcher() { |
| public boolean matches(Element child) { |
| Element match = PomEdits.findChild(child, elementName); |
| if(match == null) { |
| return true; |
| } |
| String toMatch = PomEdits.getTextValue(match); |
| return toMatch != null && toMatch.trim().equals(matchingValue); |
| } |
| }; |
| } |
| |
| /** |
| * keeps internal state, needs to be recreated for each query, when used in conjunction with out matchers shall |
| * probably be placed last. |
| * |
| * @param elementName |
| * @param index |
| * @return |
| */ |
| public static Matcher childAt(final int index) { |
| return new Matcher() { |
| int count = 0; |
| |
| public boolean matches(Element child) { |
| if(count == index) { |
| return true; |
| } |
| count++ ; |
| return false; |
| } |
| }; |
| } |
| |
| } |
