| /******************************************************************************* |
| * Copyright (c) 2011 Sonatype, Inc. |
| * All rights reserved. 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: |
| * Sonatype, Inc. - initial API and implementation |
| * Andrew Eisenberg - adapted for workspace preferences |
| *******************************************************************************/ |
| |
| package org.eclipse.m2e.core.ui.internal.preferences; |
| |
| import java.io.IOException; |
| import java.io.StringWriter; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.osgi.framework.Bundle; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ToolBarManager; |
| import org.eclipse.jface.viewers.AbstractTreeViewer; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.TreeViewerColumn; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.Clipboard; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.layout.RowLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeColumn; |
| import org.eclipse.ui.PlatformUI; |
| |
| import org.codehaus.plexus.util.xml.Xpp3Dom; |
| |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.plugin.MojoExecution; |
| import org.apache.maven.project.MavenProject; |
| |
| import org.eclipse.m2e.core.MavenPlugin; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.LifecycleMappingFactory; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.LifecycleMappingResult; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.model.LifecycleMappingMetadata; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.model.LifecycleMappingMetadataSource; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.model.PluginExecutionFilter; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.model.PluginExecutionMetadata; |
| import org.eclipse.m2e.core.internal.lifecyclemapping.model.io.xpp3.LifecycleMappingMetadataSourceXpp3Writer; |
| import org.eclipse.m2e.core.internal.project.registry.MavenProjectFacade; |
| import org.eclipse.m2e.core.lifecyclemapping.model.IPluginExecutionMetadata; |
| import org.eclipse.m2e.core.lifecyclemapping.model.PluginExecutionAction; |
| import org.eclipse.m2e.core.project.IMavenProjectFacade; |
| import org.eclipse.m2e.core.project.IMavenProjectRegistry; |
| import org.eclipse.m2e.core.project.configurator.MojoExecutionKey; |
| import org.eclipse.m2e.core.ui.internal.MavenImages; |
| import org.eclipse.m2e.core.ui.internal.Messages; |
| |
| |
| @SuppressWarnings("restriction") |
| class LifecycleMappingsViewer { |
| private static final Logger log = LoggerFactory.getLogger(LifecycleMappingsViewer.class); |
| |
| /*package*/TreeViewer mappingsTreeViewer; |
| |
| /*package*/boolean showPhases = false; |
| |
| /*package*/boolean showIgnoredExecutions = true; |
| |
| /*package*/Map<MojoExecutionKey, List<IPluginExecutionMetadata>> mappings; |
| |
| /*package*/Map<String, List<MojoExecutionKey>> phases; |
| |
| private Shell shell; |
| |
| void updateMappingsTreeViewer() { |
| mappingsTreeViewer.refresh(); |
| if(showPhases) { |
| // reveal non-empty mappings |
| mappingsTreeViewer.collapseAll(); |
| for(Map.Entry<MojoExecutionKey, List<IPluginExecutionMetadata>> entry : mappings.entrySet()) { |
| boolean expand = false; |
| if(isErrorMapping(entry.getKey())) { |
| expand = true; |
| } else { |
| expand = !isIgnoreMapping(entry.getKey(), entry.getValue()); |
| } |
| if(expand) { |
| mappingsTreeViewer.expandToLevel(entry.getKey().getLifecyclePhase(), AbstractTreeViewer.ALL_LEVELS); |
| } |
| } |
| } |
| // auto-size all columns |
| for(TreeColumn column : mappingsTreeViewer.getTree().getColumns()) { |
| column.pack(); |
| } |
| } |
| |
| /** |
| * @wbp.parser.entryPoint |
| */ |
| public Composite createContents(Composite parent) { |
| Composite container = new Composite(parent, SWT.NULL); |
| GridLayout gl_container = new GridLayout(1, false); |
| gl_container.marginWidth = 0; |
| gl_container.marginHeight = 0; |
| container.setLayout(gl_container); |
| |
| Composite optionsComposit = new Composite(container, SWT.NONE); |
| GridLayout gl_optionsComposit = new GridLayout(3, false); |
| gl_optionsComposit.marginWidth = 0; |
| gl_optionsComposit.marginHeight = 0; |
| optionsComposit.setLayout(gl_optionsComposit); |
| optionsComposit.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| |
| final Button btnShowPhases = new Button(optionsComposit, SWT.CHECK); |
| btnShowPhases.setSelection(showPhases); |
| btnShowPhases.setText(Messages.LifecycleMappingPropertyPage_showLIfecyclePhases); |
| |
| final Button btnShowIgnored = new Button(optionsComposit, SWT.CHECK); |
| btnShowIgnored.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| showIgnoredExecutions = btnShowIgnored.getSelection(); |
| updateMappingsTreeViewer(); |
| } |
| }); |
| btnShowIgnored.setSelection(showIgnoredExecutions); |
| btnShowIgnored.setText(Messages.LifecycleMappingPropertyPage_mntmShowIgnoredExecutions_text); |
| final Action actExpandAll = new Action(Messages.LifecycleMappingPropertyPage_mntmExpandAll_text, |
| MavenImages.EXPANDALL) { |
| public void run() { |
| mappingsTreeViewer.expandAll(); |
| }; |
| }; |
| actExpandAll.setEnabled(showPhases); |
| final Action actCollapseAll = new Action(Messages.LifecycleMappingPropertyPage_mntmCollapseAll_text, |
| MavenImages.COLLAPSEALL) { |
| public void run() { |
| mappingsTreeViewer.collapseAll(); |
| }; |
| }; |
| actCollapseAll.setEnabled(showPhases); |
| |
| Composite toolbarComposite = new Composite(optionsComposit, SWT.NONE); |
| toolbarComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, false, 1, 1)); |
| GridLayout gl_toolbarComposite = new GridLayout(1, false); |
| gl_toolbarComposite.marginWidth = 0; |
| gl_toolbarComposite.marginHeight = 0; |
| toolbarComposite.setLayout(gl_toolbarComposite); |
| |
| ToolBar toolBar = new ToolBar(toolbarComposite, SWT.FLAT | SWT.RIGHT); |
| ToolBarManager toolBarManager = new ToolBarManager(toolBar); |
| toolBarManager.add(actExpandAll); |
| toolBarManager.add(actCollapseAll); |
| toolBarManager.update(true); |
| |
| btnShowPhases.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| showPhases = btnShowPhases.getSelection(); |
| actExpandAll.setEnabled(showPhases); |
| actCollapseAll.setEnabled(showPhases); |
| updateMappingsTreeViewer(); |
| } |
| }); |
| |
| mappingsTreeViewer = new TreeViewer(container, SWT.BORDER); |
| Tree tree = mappingsTreeViewer.getTree(); |
| tree.setHeaderVisible(true); |
| tree.setLinesVisible(true); |
| tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1)); |
| |
| TreeViewerColumn treeViewerColumn = new TreeViewerColumn(mappingsTreeViewer, SWT.NONE); |
| TreeColumn trclmnGoal = treeViewerColumn.getColumn(); |
| trclmnGoal.setWidth(100); |
| trclmnGoal.setText(Messages.LifecycleMappingPropertyPage_pluginExecution); |
| |
| TreeViewerColumn treeViewerColumn_1 = new TreeViewerColumn(mappingsTreeViewer, SWT.NONE); |
| TreeColumn trclmnNewColumn = treeViewerColumn_1.getColumn(); |
| trclmnNewColumn.setWidth(100); |
| trclmnNewColumn.setText(Messages.LifecycleMappingPropertyPage_mapping); |
| |
| TreeViewerColumn treeViewerColumn_2 = new TreeViewerColumn(mappingsTreeViewer, SWT.NONE); |
| TreeColumn trclmnSource = treeViewerColumn_2.getColumn(); |
| trclmnSource.setWidth(100); |
| trclmnSource.setText(Messages.LifecycleMappingsViewer_trclmnSource_text); |
| |
| mappingsTreeViewer.setContentProvider(new ITreeContentProvider() { |
| |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| } |
| |
| public void dispose() { |
| } |
| |
| public boolean hasChildren(Object element) { |
| return getChildren(element) != null; |
| } |
| |
| public Object getParent(Object element) { |
| return null; |
| } |
| |
| public Object[] getElements(Object inputElement) { |
| if(showPhases) { |
| return phases.keySet().toArray(); |
| } |
| Set<MojoExecutionKey> executions; |
| if(showIgnoredExecutions) { |
| executions = mappings.keySet(); |
| } else { |
| executions = new LinkedHashSet<MojoExecutionKey>(); |
| for(Map.Entry<MojoExecutionKey, List<IPluginExecutionMetadata>> entry : mappings.entrySet()) { |
| if(!isIgnoreMapping(entry.getKey(), entry.getValue())) { |
| executions.add(entry.getKey()); |
| } |
| } |
| } |
| return executions.toArray(); |
| } |
| |
| public Object[] getChildren(Object parentElement) { |
| List<MojoExecutionKey> executions = phases.get(parentElement); |
| if(executions == null || executions.isEmpty()) { |
| return null; |
| } |
| if(showIgnoredExecutions) { |
| return executions.toArray(); |
| } |
| // filter out ignored executions |
| executions = new ArrayList<MojoExecutionKey>(executions); // clone |
| Iterator<MojoExecutionKey> iter = executions.iterator(); |
| while(iter.hasNext()) { |
| MojoExecutionKey execution = iter.next(); |
| if(isIgnoreMapping(execution, mappings.get(execution))) { |
| iter.remove(); |
| } |
| } |
| return !executions.isEmpty() ? executions.toArray() : null; |
| } |
| }); |
| |
| mappingsTreeViewer.setLabelProvider(new ITableLabelProvider() { |
| |
| public void addListener(ILabelProviderListener listener) { |
| } |
| |
| public void dispose() { |
| } |
| |
| public boolean isLabelProperty(Object element, String property) { |
| return false; |
| } |
| |
| public void removeListener(ILabelProviderListener listener) { |
| } |
| |
| public Image getColumnImage(Object element, int columnIndex) { |
| if(columnIndex == 0 && element instanceof MojoExecutionKey) { |
| return isErrorMapping((MojoExecutionKey) element) ? MavenImages.IMG_ERROR : MavenImages.IMG_PASSED; |
| } |
| return null; |
| } |
| |
| public String getColumnText(Object element, int columnIndex) { |
| if(element instanceof MojoExecutionKey) { |
| MojoExecutionKey execution = (MojoExecutionKey) element; |
| switch(columnIndex) { |
| case 0: |
| return LifecycleMappingsViewer.this.toString(execution); |
| case 1: |
| return LifecycleMappingsViewer.this.toString(execution, mappings.get(execution)); |
| case 2: |
| return getSourcelabel(execution, mappings.get(execution), false); |
| } |
| } |
| return columnIndex == 0 ? element.toString() : null; |
| } |
| }); |
| |
| Composite actionsComposite = new Composite(container, SWT.NONE); |
| actionsComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, false, 1, 1)); |
| actionsComposite.setLayout(new RowLayout(SWT.HORIZONTAL)); |
| |
| Button btnCopyToClipboard = new Button(actionsComposite, SWT.NONE); |
| btnCopyToClipboard.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| copyToClipboard(); |
| } |
| }); |
| btnCopyToClipboard.setText(Messages.LifecycleMappingPropertyPage_copyToClipboard); |
| |
| mappingsTreeViewer.setInput(phases); |
| |
| updateMappingsTreeViewer(); |
| return container; |
| } |
| |
| void copyToClipboard() { |
| if(mappings == null) { |
| return; |
| } |
| |
| LifecycleMappingMetadata meta = new LifecycleMappingMetadata(); |
| |
| for(Map.Entry<MojoExecutionKey, List<IPluginExecutionMetadata>> entry : this.mappings.entrySet()) { |
| MojoExecutionKey execution = entry.getKey(); |
| List<IPluginExecutionMetadata> mappings = entry.getValue(); |
| if(mappings != null && !mappings.isEmpty()) { |
| for(IPluginExecutionMetadata mapping : mappings) { |
| PluginExecutionMetadata clone = ((PluginExecutionMetadata) mapping).clone(); |
| setMappingSource(execution, mappings, clone); |
| meta.addPluginExecution(clone); |
| } |
| } else { |
| PluginExecutionFilter filter = new PluginExecutionFilter(execution.getGroupId(), execution.getArtifactId(), |
| execution.getVersion(), execution.getGoal()); |
| |
| PluginExecutionMetadata mapping = new PluginExecutionMetadata(); |
| mapping.setFilter(filter); |
| |
| Xpp3Dom actionDom; |
| if(LifecycleMappingFactory.isInterestingPhase(entry.getKey().getLifecyclePhase())) { |
| actionDom = new Xpp3Dom(PluginExecutionAction.error.toString()); |
| } else { |
| actionDom = new Xpp3Dom(PluginExecutionAction.ignore.toString()); |
| } |
| mapping.setActionDom(actionDom); |
| |
| setMappingSource(execution, mappings, mapping); |
| |
| meta.addPluginExecution(mapping); |
| } |
| } |
| |
| LifecycleMappingMetadataSource xml = new LifecycleMappingMetadataSource(); |
| xml.addLifecycleMapping(meta); |
| |
| StringWriter buf = new StringWriter(); |
| try { |
| new LifecycleMappingMetadataSourceXpp3Writer().write(buf, xml); |
| |
| Clipboard clipboard = new Clipboard(shell.getDisplay()); |
| |
| Object[] data = new Object[] {buf.toString()}; |
| Transfer[] dataTypes = new Transfer[] {TextTransfer.getInstance()}; |
| |
| clipboard.setContents(data, dataTypes); |
| |
| clipboard.dispose(); |
| } catch(IOException ex) { |
| // TODO log |
| } |
| } |
| |
| private void setMappingSource(MojoExecutionKey execution, List<IPluginExecutionMetadata> mappings, |
| PluginExecutionMetadata clone) { |
| clone.setComment("source: " + getSourcelabel(execution, mappings, true)); //$NON-NLS-1$ |
| } |
| |
| boolean isErrorMapping(MojoExecutionKey execution) { |
| List<IPluginExecutionMetadata> mappings = this.mappings.get(execution); |
| if(mappings == null || mappings.isEmpty()) { |
| return LifecycleMappingFactory.isInterestingPhase(execution.getLifecyclePhase()); |
| } |
| for(IPluginExecutionMetadata mapping : mappings) { |
| if(PluginExecutionAction.error == mapping.getAction()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| boolean isIgnoreMapping(MojoExecutionKey execution, List<IPluginExecutionMetadata> mappings) { |
| if(mappings == null || mappings.isEmpty()) { |
| return !LifecycleMappingFactory.isInterestingPhase(execution.getLifecyclePhase()); |
| } |
| for(IPluginExecutionMetadata mapping : mappings) { |
| if(PluginExecutionAction.ignore != mapping.getAction()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| String toString(MojoExecutionKey execution, List<IPluginExecutionMetadata> mappings) { |
| StringBuilder sb = new StringBuilder(); |
| if(mappings != null && !mappings.isEmpty()) { |
| for(IPluginExecutionMetadata mapping : mappings) { |
| if(sb.length() > 0) { |
| sb.append(','); |
| } |
| sb.append(mapping.getAction().toString()); |
| } |
| } else { |
| if(LifecycleMappingFactory.isInterestingPhase(execution.getLifecyclePhase())) { |
| sb.append(PluginExecutionAction.error.toString()); |
| } else { |
| sb.append(PluginExecutionAction.ignore.toString()); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| String getSourcelabel(MojoExecutionKey execution, List<IPluginExecutionMetadata> mappings, boolean detailed) { |
| LinkedHashSet<String> sources = new LinkedHashSet<String>(); |
| if(mappings != null && !mappings.isEmpty()) { |
| for(IPluginExecutionMetadata mapping : mappings) { |
| LifecycleMappingMetadataSource metadata = ((PluginExecutionMetadata) mapping).getSource(); |
| if(metadata != null) { |
| Object source = metadata.getSource(); |
| if(source instanceof String) { |
| sources.add((String) source); |
| } else if(source instanceof Artifact) { |
| sources.add(getSourceLabel((Artifact) source, detailed)); |
| } else if(source instanceof MavenProject) { |
| sources.add(getSourceLabel((MavenProject) source, detailed)); |
| } else if(source instanceof Bundle) { |
| sources.add(getSourceLabel((Bundle) source, detailed)); |
| } else { |
| sources.add("unknown"); //$NON-NLS-1$ |
| } |
| } |
| } |
| } else { |
| if(!LifecycleMappingFactory.isInterestingPhase(execution.getLifecyclePhase())) { |
| sources.add("uninteresting"); //$NON-NLS-1$ |
| } |
| } |
| StringBuilder sb = new StringBuilder(); |
| for(String source : sources) { |
| if(sb.length() > 0) { |
| sb.append(','); |
| } |
| sb.append(source); |
| } |
| return sb.toString(); |
| } |
| |
| private String getSourceLabel(Bundle bundle, boolean detailed) { |
| StringBuilder sb = new StringBuilder("extension"); //$NON-NLS-1$ |
| if(detailed) { |
| sb.append('(').append(bundle.getSymbolicName()).append('_').append(bundle.getVersion()).append(')'); |
| } |
| return sb.toString(); |
| } |
| |
| private String getSourceLabel(MavenProject project, boolean detailed) { |
| StringBuilder sb = new StringBuilder("pom"); //$NON-NLS-1$ |
| if(detailed) { |
| sb.append('(').append(project.toString()).append(')'); |
| } |
| return sb.toString(); |
| } |
| |
| private String getSourceLabel(Artifact plugin, boolean detailed) { |
| StringBuilder sb = new StringBuilder("maven-plugin"); //$NON-NLS-1$ |
| if(detailed) { |
| sb.append('(').append(plugin.toString()).append(')'); |
| } |
| return sb.toString(); |
| } |
| |
| String toString(MojoExecutionKey execution) { |
| // http://maven.apache.org/guides/plugin/guide-java-plugin-development.html#Shortening_the_Command_Line |
| |
| StringBuilder sb = new StringBuilder(); |
| |
| // TODO show groupId, but only if not a known plugin groupId |
| |
| // shorten artifactId |
| String artifactId = execution.getArtifactId(); |
| if(artifactId.endsWith("-maven-plugin")) { //$NON-NLS-1$ |
| artifactId = artifactId.substring(0, artifactId.length() - "-maven-plugin".length()); //$NON-NLS-1$ |
| } else if(artifactId.startsWith("maven-") && artifactId.endsWith("-plugin")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| artifactId = artifactId.substring("maven-".length(), artifactId.length() - "-plugin".length()); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| sb.append(artifactId).append(':').append(execution.getGoal()); |
| |
| // only show execution id if necessary |
| int count = 0; |
| for(MojoExecutionKey other : mappings.keySet()) { |
| if(eq(execution.getGroupId(), other.getGroupId()) && eq(execution.getArtifactId(), other.getArtifactId()) |
| && eq(execution.getGoal(), other.getGoal())) { |
| count++ ; |
| } |
| } |
| if(count > 1) { |
| sb.append(" (").append(execution.getExecutionId()).append(")"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| return sb.toString(); |
| } |
| |
| static <T> boolean eq(T a, T b) { |
| return a != null ? a.equals(b) : b == null; |
| } |
| |
| public void setTarget(final IProject project) { |
| if(project == null) { |
| // TODO FIXADE find the mojo execution mapping for the workspace...How do I do this? |
| } else { |
| try { |
| PlatformUI.getWorkbench().getProgressService().run(false, false, monitor -> { |
| final IMavenProjectRegistry projectRegistry = MavenPlugin.getMavenProjectRegistry(); |
| final IMavenProjectFacade facade = projectRegistry.getProject(project); |
| if(facade == null) { |
| return; |
| } |
| try { |
| projectRegistry.execute(facade, (context, monitor1) -> { |
| MavenProject mavenProject = facade.getMavenProject(monitor1); |
| List<MojoExecution> mojoExecutions = ((MavenProjectFacade) facade).getMojoExecutions(monitor1); |
| LifecycleMappingResult mappingResult = LifecycleMappingFactory.calculateLifecycleMapping(mavenProject, |
| mojoExecutions, facade.getResolverConfiguration().getLifecycleMappingId(), monitor1); |
| mappings = mappingResult.getMojoExecutionMapping(); |
| return null; |
| }, monitor); |
| } catch(CoreException ex) { |
| throw new InvocationTargetException(ex); |
| } |
| }); |
| } catch(InvocationTargetException ex) { |
| log.error(ex.getMessage(), ex); |
| } catch(InterruptedException ex) { |
| log.error(ex.getMessage(), ex); |
| } |
| } |
| phases = new LinkedHashMap<String, List<MojoExecutionKey>>(); |
| if(mappings != null) { |
| for(MojoExecutionKey execution : mappings.keySet()) { |
| List<MojoExecutionKey> executions = phases.get(execution.getLifecyclePhase()); |
| if(executions == null) { |
| executions = new ArrayList<MojoExecutionKey>(); |
| phases.put(execution.getLifecyclePhase(), executions); |
| } |
| executions.add(execution); |
| } |
| } |
| } |
| |
| /** |
| * @param shell |
| */ |
| public void setShell(Shell shell) { |
| this.shell = shell; |
| } |
| |
| protected boolean isValid() { |
| return mappings != null; |
| } |
| } |
