plugins/Copyright/src/com/maddyhome/idea/copyright/options/Options.java

   1 /*
   2  *  Copyright 2000-2007 JetBrains s.r.o.
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *  http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16
  17 package com.maddyhome.idea.copyright.options;
  18
  19 import com.intellij.openapi.diagnostic.Logger;
  20 import com.intellij.openapi.fileTypes.StdFileTypes;
  21 import com.intellij.openapi.util.InvalidDataException;
  22 import com.intellij.openapi.util.JDOMExternalizable;
  23 import com.intellij.openapi.util.WriteExternalException;
  24 import com.maddyhome.idea.copyright.util.FileTypeUtil;
  25 import org.jdom.Element;
  26 import org.jetbrains.annotations.Nullable;
  27
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.TreeMap;
  31
  32 /**
  33  */
  34 public class Options implements JDOMExternalizable, Cloneable
  35 {
  36     public Options()
  37     {
  38         logger.info("Options()");
  39     }
  40
  41
  42     public LanguageOptions getOptions(String name)
  43     {
  44         String lang = FileTypeUtil.getInstance().getFileTypeNameByName(name);
  45         LanguageOptions res = options.get(lang);
  46         if (res == null)
  47         {
  48             res = LanguageOptionsFactory.createOptions(lang);
  49         }
  50
  51         return res;
  52     }
  53
  54     public LanguageOptions getTemplateOptions()
  55     {
  56         return getOptions(LANG_TEMPLATE);
  57     }
  58
  59     public void setOptions(String name, LanguageOptions options)
  60     {
  61         String lang = FileTypeUtil.getInstance().getFileTypeNameByName(name);
  62         this.options.put(lang, options);
  63     }
  64
  65     public void setTemplateOptions(LanguageOptions options)
  66     {
  67         setOptions(LANG_TEMPLATE, options);
  68     }
  69
  70    @Nullable
  71     public LanguageOptions getMergedOptions(String name)
  72     {
  73         try
  74         {
  75             LanguageOptions lang = getOptions(name).clone();
  76             LanguageOptions temp = getTemplateOptions().clone();
  77             switch (lang.getFileTypeOverride())
  78             {
  79                 case LanguageOptions.USE_NONE:
  80                     return null;
  81                 case LanguageOptions.USE_TEMPLATE:
  82                     temp.setFileLocation(lang.getFileLocation());
  83                     temp.setFileTypeOverride(lang.getFileTypeOverride());
  84                     lang = temp;
  85                     break;
  86                 case LanguageOptions.USE_TEXT:
  87                     break;
  88             }
  89
  90             return lang;
  91         }
  92         catch (CloneNotSupportedException e)
  93         {
  94             // This shouldn't happen
  95         }
  96
  97         return null;
  98     }
  99
 100
 101     public void readExternal(Element element) throws InvalidDataException
 102     {
 103         logger.debug("readExternal()");
 104         List langs = element.getChildren("LanguageOptions");
 105         if (langs != null && langs.size() > 0)
 106         {
 107             //noinspection ForLoopReplaceableByForEach
 108             for (int i = 0; i < langs.size(); i++)
 109             {
 110                 Element lang = (Element)langs.get(i);
 111                 String name = lang.getAttributeValue("name");
 112                 LanguageOptions opts = LanguageOptionsFactory.createOptions(name);
 113                 opts.readExternal(lang);
 114
 115                 setOptions(name, opts);
 116             }
 117         }
 118         else
 119         {
 120             Element root = null;
 121             Element jOpts = element.getChild("JavaOptions");
 122             if (jOpts != null) // version 2.1.x
 123             {
 124                 root = jOpts;
 125             }
 126             else // versions 0.0.1 - 2.0.x
 127             {
 128                 Element child = element.getChild("option");
 129                 if (child != null && child.getAttribute("name") != null)
 130                 {
 131                     root = element;
 132                 }
 133             }
 134             if (root != null)
 135             {
 136                 String lname = StdFileTypes.JAVA.getName();
 137                 LanguageOptions opts = LanguageOptionsFactory.createOptions(lname);
 138                 opts.setFileTypeOverride(LanguageOptions.USE_TEMPLATE);
 139                 List children = root.getChildren("option");
 140                 for (Object option : children)
 141                 {
 142                     String name = ((Element)option).getAttributeValue("name");
 143                     String val = ((Element)option).getAttributeValue("value");
 144                     if ("body".equals(name))
 145                     {
 146                         //todo opts.setNotice(val);
 147                     }
 148                     else if ("location".equals(name))
 149                     {
 150                         opts.setFileLocation(Integer.parseInt(val));
 151                     }
 152                 }
 153
 154                 setOptions(lname, opts);
 155             }
 156         }
 157
 158         logger.debug("options=" + this);
 159     }
 160
 161     public void writeExternal(Element element) throws WriteExternalException
 162     {
 163         logger.debug("writeExternal()");
 164
 165         for (String lang : options.keySet())
 166         {
 167             LanguageOptions opts = options.get(lang);
 168
 169             Element elem = new Element("LanguageOptions");
 170             elem.setAttribute("name", lang);
 171             element.addContent(elem);
 172             opts.writeExternal(elem);
 173         }
 174
 175         logger.debug("options=" + this);
 176     }
 177
 178     public boolean equals(Object o)
 179     {
 180         if (this == o)
 181         {
 182             return true;
 183         }
 184         if (o == null || getClass() != o.getClass())
 185         {
 186             return false;
 187         }
 188
 189         final Options options1 = (Options)o;
 190
 191         return options.equals(options1.options);
 192     }
 193
 194     public int hashCode()
 195     {
 196         int result;
 197         result = options.hashCode();
 198         return result;
 199     }
 200
 201     public String toString()
 202     {
 203         final StringBuffer sb = new StringBuffer();
 204         sb.append("Options");
 205         sb.append("{options=").append(options);
 206         sb.append('}');
 207         return sb.toString();
 208     }
 209
 210     public Options clone() throws CloneNotSupportedException
 211     {
 212         Options res = (Options)super.clone();
 213         res.options = new TreeMap<String, LanguageOptions>();
 214         for (String lang : options.keySet())
 215         {
 216             LanguageOptions opts = options.get(lang);
 217             res.options.put(lang, opts.clone());
 218         }
 219
 220         return res;
 221     }
 222
 223     private Map<String, LanguageOptions> options = new TreeMap<String, LanguageOptions>();
 224     private static final String LANG_TEMPLATE = "__TEMPLATE__";
 225
 226     private static Logger logger = Logger.getInstance(Options.class.getName());
 227 }