net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/corext/template/TemplateSet.java

   1 /*
   2  * (c) Copyright IBM Corp. 2000, 2001.
   3  * All Rights Reserved.
   4  */
   5 package net.sourceforge.phpdt.internal.corext.template;
   6
   7 import java.io.File;
   8 import java.io.FileInputStream;
   9 import java.io.FileOutputStream;
  10 import java.io.IOException;
  11 import java.io.InputStream;
  12 import java.io.OutputStream;
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.Comparator;
  16 import java.util.Iterator;
  17 import java.util.List;
  18
  19 import javax.xml.parsers.DocumentBuilder;
  20 import javax.xml.parsers.DocumentBuilderFactory;
  21 import javax.xml.parsers.ParserConfigurationException;
  22
  23 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  24
  25 import org.apache.xml.serialize.OutputFormat;
  26 import org.apache.xml.serialize.Serializer;
  27 import org.apache.xml.serialize.SerializerFactory;
  28 import org.eclipse.core.runtime.CoreException;
  29 import org.eclipse.core.runtime.IStatus;
  30 import org.w3c.dom.Attr;
  31 import org.w3c.dom.Document;
  32 import org.w3c.dom.NamedNodeMap;
  33 import org.w3c.dom.Node;
  34 import org.w3c.dom.NodeList;
  35 import org.w3c.dom.Text;
  36 import org.xml.sax.InputSource;
  37 import org.xml.sax.SAXException;
  38 import org.xml.sax.SAXParseException;
  39
  40 /**
  41  * <code>ObfuscatorIgnoreSet</code> manages a collection of templates and makes them
  42  * persistent.
  43  */
  44 public class TemplateSet {
  45
  46   private static class TemplateComparator implements Comparator {
  47     public int compare(Object arg0, Object arg1) {
  48       if (arg0 == arg1)
  49         return 0;
  50
  51       if (arg0 == null)
  52         return -1;
  53
  54       Template template0 = (Template) arg0;
  55       Template template1 = (Template) arg1;
  56
  57       return template0.getName().compareTo(template1.getName());
  58     }
  59   }
  60
  61   private static final String TEMPLATE_TAG = "template"; //$NON-NLS-1$
  62   private static final String NAME_ATTRIBUTE = "name"; //$NON-NLS-1$
  63   private static final String DESCRIPTION_ATTRIBUTE = "description"; //$NON-NLS-1$
  64   private static final String CONTEXT_ATTRIBUTE = "context"; //$NON-NLS-1$
  65   private static final String ENABLED_ATTRIBUTE = "enabled"; //$NON-NLS-1$
  66
  67   private List fTemplates = new ArrayList();
  68   private Comparator fTemplateComparator = new TemplateComparator();
  69   private Template[] fSortedTemplates = new Template[0];
  70
  71   /**
  72    * Convenience method for reading templates from a file.
  73    *
  74    * @see #addFromStream(InputStream)
  75    */
  76   public void addFromFile(File file) throws CoreException {
  77     InputStream stream = null;
  78
  79     try {
  80       stream = new FileInputStream(file);
  81       addFromStream(stream);
  82
  83     } catch (IOException e) {
  84       throwReadException(e);
  85
  86     } finally {
  87       try {
  88         if (stream != null)
  89           stream.close();
  90       } catch (IOException e) {
  91       }
  92     }
  93   }
  94
  95   /**
  96    * Reads templates from a XML stream and adds them to the template set.
  97    */
  98   public void addFromStream(InputStream stream) throws CoreException {
  99     try {
 100       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 101       DocumentBuilder parser = factory.newDocumentBuilder();
 102       Document document = parser.parse(new InputSource(stream));
 103       NodeList elements = document.getElementsByTagName(TEMPLATE_TAG);
 104
 105       int count = elements.getLength();
 106       for (int i = 0; i != count; i++) {
 107         Node node = elements.item(i);
 108         NamedNodeMap attributes = node.getAttributes();
 109
 110         if (attributes == null)
 111           continue;
 112
 113         String name = getAttributeValue(attributes, NAME_ATTRIBUTE);
 114         String description = getAttributeValue(attributes, DESCRIPTION_ATTRIBUTE);
 115         String context = getAttributeValue(attributes, CONTEXT_ATTRIBUTE);
 116         Node enabledNode = attributes.getNamedItem(ENABLED_ATTRIBUTE);
 117
 118         if (name == null || description == null || context == null)
 119           throw new SAXException(TemplateMessages.getString("TemplateSet.error.missing.attribute")); //$NON-NLS-1$
 120
 121         boolean enabled = (enabledNode == null) || (enabledNode.getNodeValue().equals("true")); //$NON-NLS-1$
 122
 123         StringBuffer buffer = new StringBuffer();
 124         NodeList children = node.getChildNodes();
 125         for (int j = 0; j != children.getLength(); j++) {
 126           String value = children.item(j).getNodeValue();
 127           if (value != null)
 128             buffer.append(value);
 129         }
 130         String pattern = buffer.toString().trim();
 131
 132         Template template = new Template(name, description, context, pattern);
 133         template.setEnabled(enabled);
 134         add(template);
 135       }
 136
 137       sort();
 138
 139     } catch (ParserConfigurationException e) {
 140       throwReadException(e);
 141     } catch (IOException e) {
 142       throwReadException(e);
 143     } catch (SAXParseException e) {
 144                         System.out.println("SAXParseException in line:"+e.getLineNumber()+" column:"+e.getColumnNumber());
 145       throwReadException(e);
 146     } catch (SAXException e) {
 147       throwReadException(e);
 148     }
 149   }
 150
 151   private String getAttributeValue(NamedNodeMap attributes, String name) {
 152     Node node = attributes.getNamedItem(name);
 153
 154     return node == null ? null : node.getNodeValue();
 155   }
 156
 157   /**
 158    * Convenience method for saving to a file.
 159    *
 160    * @see #saveToStream(OutputStream)
 161    */
 162   public void saveToFile(File file) throws CoreException {
 163     OutputStream stream = null;
 164
 165     try {
 166       stream = new FileOutputStream(file);
 167       saveToStream(stream);
 168
 169     } catch (IOException e) {
 170       throwWriteException(e);
 171
 172     } finally {
 173       try {
 174         if (stream != null)
 175           stream.close();
 176       } catch (IOException e) {
 177       }
 178     }
 179   }
 180
 181   /**
 182    * Saves the template set as XML.
 183    */
 184   public void saveToStream(OutputStream stream) throws CoreException {
 185     try {
 186       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 187       DocumentBuilder builder = factory.newDocumentBuilder();
 188       Document document = builder.newDocument();
 189
 190       Node root = document.createElement("templates"); // $NON-NLS-1$ //$NON-NLS-1$
 191       document.appendChild(root);
 192
 193       for (int i = 0; i != fTemplates.size(); i++) {
 194         Template template = (Template) fTemplates.get(i);
 195
 196         Node node = document.createElement("template"); // $NON-NLS-1$ //$NON-NLS-1$
 197         root.appendChild(node);
 198
 199         NamedNodeMap attributes = node.getAttributes();
 200
 201         Attr name = document.createAttribute(NAME_ATTRIBUTE);
 202         name.setValue(template.getName());
 203         attributes.setNamedItem(name);
 204
 205         Attr description = document.createAttribute(DESCRIPTION_ATTRIBUTE);
 206         description.setValue(template.getDescription());
 207         attributes.setNamedItem(description);
 208
 209         Attr context = document.createAttribute(CONTEXT_ATTRIBUTE);
 210         context.setValue(template.getContextTypeName());
 211         attributes.setNamedItem(context);
 212
 213         Attr enabled = document.createAttribute(ENABLED_ATTRIBUTE);
 214         enabled.setValue(template.isEnabled() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$
 215         attributes.setNamedItem(enabled);
 216
 217         Text pattern = document.createTextNode(template.getPattern());
 218         node.appendChild(pattern);
 219       }
 220
 221       OutputFormat format = new OutputFormat();
 222       format.setPreserveSpace(true);
 223       Serializer serializer = SerializerFactory.getSerializerFactory("xml").makeSerializer(stream, format); //$NON-NLS-1$
 224       serializer.asDOMSerializer().serialize(document);
 225
 226     } catch (ParserConfigurationException e) {
 227       throwWriteException(e);
 228     } catch (IOException e) {
 229       throwWriteException(e);
 230     }
 231   }
 232
 233   private static void throwReadException(Throwable t) throws CoreException {
 234     PHPeclipsePlugin.log(t);
 235     //          IStatus status= new JavaUIStatus(JavaStatusConstants.TEMPLATE_IO_EXCEPTION,
 236     //                  ObfuscatorMessages.getString("TemplateSet.error.read"), t); //$NON-NLS-1$
 237     //          throw new JavaUIException(status);
 238   }
 239
 240   private static void throwWriteException(Throwable t) throws CoreException {
 241     PHPeclipsePlugin.log(t);
 242     //          IStatus status= new JavaUIStatus(JavaStatusConstants.TEMPLATE_IO_EXCEPTION,
 243     //                  ObfuscatorMessages.getString("TemplateSet.error.write"), t); //$NON-NLS-1$
 244     //          throw new JavaUIException(status);
 245   }
 246
 247   /**
 248    * Adds a template to the set.
 249    */
 250   public void add(Template template) {
 251     if (exists(template))
 252       return; // ignore duplicate
 253
 254     fTemplates.add(template);
 255     sort();
 256   }
 257
 258   private boolean exists(Template template) {
 259     for (Iterator iterator = fTemplates.iterator(); iterator.hasNext();) {
 260       Template anotherTemplate = (Template) iterator.next();
 261
 262       if (template.equals(anotherTemplate))
 263         return true;
 264     }
 265
 266     return false;
 267   }
 268
 269   /**
 270    * Removes a template to the set.
 271    */
 272   public void remove(Template template) {
 273     fTemplates.remove(template);
 274     sort();
 275   }
 276
 277   /**
 278    * Empties the set.
 279    */
 280   public void clear() {
 281     fTemplates.clear();
 282     sort();
 283   }
 284
 285   /**
 286    * Returns all templates.
 287    */
 288   public Template[] getTemplates() {
 289     return (Template[]) fTemplates.toArray(new Template[fTemplates.size()]);
 290   }
 291
 292   /**
 293    * Returns all templates with a given name.
 294    */
 295   public Template[] getTemplates(String name) {
 296     ArrayList res = new ArrayList();
 297     for (Iterator iterator = fTemplates.iterator(); iterator.hasNext();) {
 298       Template curr = (Template) iterator.next();
 299       if (curr.getName().equals(name)) {
 300         res.add(curr);
 301       }
 302     }
 303     return (Template[]) res.toArray(new Template[res.size()]);
 304   }
 305
 306   private void sort() {
 307     fSortedTemplates = (Template[]) fTemplates.toArray(new Template[fTemplates.size()]);
 308     Arrays.sort(fSortedTemplates, fTemplateComparator);
 309   }
 310
 311 }