\r
/**\r
* main process.\r
+ * @throws org.apache.commons.cli.ParseException \r
*/\r
public Main(String[] args) throws ParseException{\r
Options options = buildOptions();\r
*/\r
\r
import java.awt.BorderLayout;\r
-import java.awt.Component;\r
-import java.awt.GridLayout;\r
+import java.awt.FlowLayout;\r
import java.awt.event.ActionEvent;\r
import java.awt.event.ActionListener;\r
+import java.awt.event.MouseAdapter;\r
+import java.awt.event.MouseEvent;\r
+import java.util.HashMap;\r
+import java.util.Map;\r
\r
import javax.swing.Box;\r
-import javax.swing.DefaultCellEditor;\r
+import javax.swing.DefaultListModel;\r
import javax.swing.JButton;\r
+import javax.swing.JCheckBox;\r
import javax.swing.JComboBox;\r
import javax.swing.JComponent;\r
import javax.swing.JLabel;\r
+import javax.swing.JList;\r
import javax.swing.JOptionPane;\r
import javax.swing.JPanel;\r
import javax.swing.JScrollPane;\r
-import javax.swing.JTable;\r
import javax.swing.JTextField;\r
import javax.swing.border.TitledBorder;\r
import javax.swing.event.DocumentEvent;\r
import javax.swing.event.DocumentListener;\r
import javax.swing.event.ListSelectionEvent;\r
import javax.swing.event.ListSelectionListener;\r
-import javax.swing.table.DefaultTableCellRenderer;\r
-import javax.swing.table.DefaultTableModel;\r
-import javax.swing.table.TableCellRenderer;\r
-import javax.swing.table.TableColumn;\r
-import javax.swing.table.TableColumnModel;\r
\r
import jp.naist.se.stigmata.utils.WellknownClassJudgeRule;\r
import jp.naist.se.stigmata.utils.WellknownClassManager;\r
\r
/**\r
+ * Well-known classes judge rules management pane.\r
+ * \r
* @author Haruaki TAMADA\r
* @version $Revision$ $Date$\r
*/\r
public class WellknownClassesSettingsPane extends JPanel{\r
private static final long serialVersionUID = 329734546345634532L;\r
\r
- private JTable sectionTable = null;\r
- private DefaultTableModel model;\r
- private WellknownClassManager manager;\r
private StigmataFrame stigmata;\r
- private JComboBox checkPartType;\r
- private JComboBox matchType;\r
- private String matchTypeColumnIdentifier;\r
- private String checkPartColumnIdentifier;\r
- private String patternColumnIdentifier;\r
+ private WellknownClassManager manager;\r
+ private JList list;\r
+ private DefaultListModel listmodel;\r
+\r
+ private Map<String, String> matchTypeMap = new HashMap<String, String>();\r
+ private Map<String, String> partTypeMap = new HashMap<String, String>();\r
\r
public WellknownClassesSettingsPane(StigmataFrame stigmata){\r
this.stigmata = stigmata;\r
\r
public synchronized void setWellknownClasses(WellknownClassManager manager){\r
manager.clear();\r
- for(int i = 0; i < model.getRowCount(); i++){\r
- int partType = getPartType(model.getValueAt(i, 0));\r
- int match = getMatchType(model.getValueAt(i, 1));\r
- String value = (String)model.getValueAt(i, 2);\r
- WellknownClassJudgeRule sect = new WellknownClassJudgeRule(value, partType | match);\r
- manager.add(sect);\r
+ for(int i = 0; i < listmodel.getSize(); i++){\r
+ WellknownClassJudgeRule rule = (WellknownClassJudgeRule)listmodel.getElementAt(i);\r
+ manager.add(rule);\r
}\r
}\r
\r
}\r
\r
public void reset(){\r
- for(int i = model.getRowCount() - 1; i >= 0; i--){\r
- model.removeRow(i);\r
- }\r
+ listmodel.clear();\r
initializeData();\r
}\r
\r
return manager.isWellKnownClass(className);\r
}\r
\r
- private int getPartType(Object object){\r
- if(object instanceof Integer){\r
- return ((Integer)object).intValue();\r
- }\r
- else{\r
- if(object.equals(Messages.getString("fully.label"))){\r
- return WellknownClassJudgeRule.FULLY_TYPE;\r
- }\r
- else if(object.equals(Messages.getString("package.label"))){\r
- return WellknownClassJudgeRule.PACKAGE_TYPE;\r
- }\r
- else if(object.equals(Messages.getString("classname.label"))){\r
- return WellknownClassJudgeRule.CLASS_NAME_TYPE;\r
- }\r
- else if(object.equals(Messages.getString("exclude.label"))){\r
- return WellknownClassJudgeRule.EXCLUDE_TYPE;\r
+ private String findType(JComboBox combo, Map<String, String> map){\r
+ String item = (String)combo.getSelectedItem();\r
+ for(Map.Entry<String, String> entry: map.entrySet()){\r
+ if(item.equals(entry.getValue())){\r
+ return entry.getKey();\r
}\r
}\r
- return WellknownClassJudgeRule.FULLY_TYPE;\r
+ return null;\r
}\r
\r
- private int getMatchType(Object object){\r
- if(object instanceof Integer){\r
- return ((Integer)object).intValue();\r
+ public void addRule(WellknownClassJudgeRule rule){\r
+ if(rule != null){\r
+ listmodel.addElement(rule);\r
}\r
- else{\r
- if(object.equals(Messages.getString("prefix.label"))){\r
- return WellknownClassJudgeRule.PREFIX_TYPE;\r
- }\r
- else if(object.equals(Messages.getString("suffix.label"))){ \r
- return WellknownClassJudgeRule.SUFFIX_TYPE;\r
- }\r
- else if(object.equals(Messages.getString("exactmatch.label"))){\r
- return WellknownClassJudgeRule.MATCH_TYPE;\r
- }\r
- }\r
- return WellknownClassJudgeRule.PREFIX_TYPE;\r
}\r
\r
- public void addSection(){\r
- JPanel inputPanel = new JPanel(new GridLayout(3, 2));\r
- JTextField text = new JTextField();\r
- inputPanel.setOpaque(true);\r
- inputPanel.add(new JLabel(matchTypeColumnIdentifier));\r
- inputPanel.add(matchType);\r
- inputPanel.add(new JLabel(checkPartColumnIdentifier));\r
- inputPanel.add(checkPartType);\r
- inputPanel.add(new JLabel(patternColumnIdentifier));\r
- inputPanel.add(text);\r
-\r
- int value = JOptionPane.showConfirmDialog(\r
- stigmata, inputPanel, Messages.getString("addwellknown.dialog.title"),\r
- JOptionPane.OK_CANCEL_OPTION\r
- );\r
- if(value == JOptionPane.OK_OPTION){\r
- int part = getPartType(checkPartType.getSelectedItem());\r
- int match = getMatchType(matchType.getSelectedItem());\r
- String pattern = text.getText();\r
-\r
- model.addRow(new Object[] { new Integer(part), new Integer(match), pattern, });\r
+ public void editRule(int index){\r
+ WellknownClassJudgeRule rule = (WellknownClassJudgeRule)listmodel.getElementAt(index);\r
+ WellknownClassJudgeRule newrule = createOrUpdateRule(rule);\r
+ if(newrule != null){\r
+ listmodel.setElementAt(newrule, index);\r
}\r
- adjustColumnPreferredWidths(sectionTable);\r
}\r
\r
+\r
private void initializeData(){\r
- WellknownClassJudgeRule[] sections = manager.getSections();\r
- for(WellknownClassJudgeRule section : sections){\r
- model.addRow(new Object[] { new Integer(section.getMatchPartType()),\r
- new Integer(section.getMatchType()), section.getName() });\r
+ for(WellknownClassJudgeRule rule : manager){\r
+ listmodel.addElement(rule);\r
}\r
- adjustColumnPreferredWidths(sectionTable);\r
- }\r
\r
- /**\r
- * copy from Swing Hacks.\r
- */\r
- private void adjustColumnPreferredWidths(JTable table){\r
- TableColumnModel columnModel = table.getColumnModel();\r
- for(int col = 0; col < table.getColumnCount(); col++){\r
- int maxWidth = 0;\r
- for(int row = 0; row < table.getRowCount(); row++){\r
- TableCellRenderer renderer = table.getCellRenderer(row, col);\r
- Object value = table.getValueAt(row, col);\r
- Component component = renderer.getTableCellRendererComponent(table, value, false,\r
- false, row, col);\r
- maxWidth = (int)Math.max(component.getPreferredSize().getWidth(), maxWidth);\r
- }\r
- TableColumn column = columnModel.getColumn(col);\r
- column.setPreferredWidth(maxWidth);\r
+ for(WellknownClassJudgeRule.MatchType type: WellknownClassJudgeRule.MatchType.values()){\r
+ matchTypeMap.put(type.name(), Messages.getString("matchtype." + type.name()));\r
+ }\r
+ for(WellknownClassJudgeRule.MatchPartType type: WellknownClassJudgeRule.MatchPartType.values()){\r
+ partTypeMap.put(type.name(), Messages.getString("matchparttype." + type.name()));\r
}\r
}\r
\r
private void initLayouts(){\r
setLayout(new BorderLayout());\r
-\r
JPanel center = new JPanel(new BorderLayout());\r
- JScrollPane scroll = new JScrollPane();\r
+ listmodel = new DefaultListModel();\r
+\r
+ list = new JList(listmodel);\r
+ JScrollPane scroll = new JScrollPane(list);\r
\r
- scroll.setViewportView(getSectionTable());\r
center.add(scroll, BorderLayout.CENTER);\r
center.add(createSouthPane(), BorderLayout.SOUTH);\r
- center.setBorder(new TitledBorder(Messages.getString("rules.border")));\r
\r
add(center, BorderLayout.CENTER);\r
- add(getCheckPanel(), BorderLayout.SOUTH);\r
+ add(createCheckPane(), BorderLayout.SOUTH);\r
}\r
\r
- private JComponent getCheckPanel(){\r
+ private JComponent createCheckPane(){\r
final JTextField text = new JTextField();\r
final JButton checkButton = Utility.createButton("checkwellknown");\r
final JLabel label = new JLabel(Utility.getIcon("wellknownclasschecker.default.icon"));\r
JButton addButton = Utility.createButton("addwellknown");\r
final JButton removeButton = Utility.createButton("removewellknown");\r
removeButton.setEnabled(false);\r
+ final JButton updateButton = Utility.createButton("updatewellknown");\r
+ updateButton.setEnabled(false);\r
\r
southPanel.add(Box.createHorizontalGlue());\r
southPanel.add(addButton);\r
southPanel.add(Box.createHorizontalGlue());\r
+ southPanel.add(updateButton);\r
+ southPanel.add(Box.createHorizontalGlue());\r
southPanel.add(removeButton);\r
southPanel.add(Box.createHorizontalGlue());\r
\r
addButton.addActionListener(new ActionListener(){\r
public void actionPerformed(ActionEvent e){\r
- addSection();\r
+ addRule(createOrUpdateRule(null));\r
+ }\r
+ });\r
+ updateButton.addActionListener(new ActionListener(){\r
+ public void actionPerformed(ActionEvent e){\r
+ editRule(list.getSelectedIndex());\r
}\r
});\r
\r
removeButton.addActionListener(new ActionListener(){\r
public void actionPerformed(ActionEvent e){\r
- int[] rows = sectionTable.getSelectedRows();\r
- for(int i = rows.length - 1; i >= 0; i--){\r
- model.removeRow(rows[i]);\r
+ int[] indeces = list.getSelectedIndices();\r
+ for(int i = indeces.length - 1; i >= 0; i--){\r
+ listmodel.removeElementAt(indeces[i]);\r
}\r
- adjustColumnPreferredWidths(sectionTable);\r
+ list.getSelectionModel().clearSelection();\r
}\r
});\r
\r
- sectionTable.getSelectionModel().addListSelectionListener(new ListSelectionListener(){\r
+ list.addMouseListener(new MouseAdapter(){\r
+ @Override\r
+ public void mouseClicked(MouseEvent e){\r
+ if(e.getClickCount() == 2){\r
+ editRule(list.getSelectedIndex());\r
+ }\r
+ }\r
+ });\r
+\r
+ list.getSelectionModel().addListSelectionListener(new ListSelectionListener(){\r
public void valueChanged(ListSelectionEvent arg0){\r
- removeButton.setEnabled(sectionTable.getSelectedRowCount() > 0);\r
+ int[] indeces = list.getSelectedIndices();\r
+ removeButton.setEnabled(indeces != null && indeces.length > 0);\r
+ updateButton.setEnabled(indeces != null && indeces.length == 1);\r
}\r
});\r
\r
return southPanel;\r
}\r
\r
- /**\r
- * This method initializes sectionTable\r
- * \r
- * @return javax.swing.JTable\r
- */\r
- private JTable getSectionTable(){\r
- if(sectionTable == null){\r
- model = new DefaultTableModel(0, 3);\r
- matchTypeColumnIdentifier = Messages.getString("matchtype.table.column");\r
- checkPartColumnIdentifier = Messages.getString("checkpart.table.column");\r
- patternColumnIdentifier = Messages.getString("pattern.table.column");\r
- model.setColumnIdentifiers(new Object[] { checkPartColumnIdentifier,\r
- matchTypeColumnIdentifier, patternColumnIdentifier, });\r
- sectionTable = new JTable(model);\r
-\r
- checkPartType = new JComboBox();\r
- final String[] checkPartItems = Messages.getStringArray("checkpart.items");\r
- for(int i = 0; i < checkPartItems.length; i++){\r
- checkPartType.addItem(checkPartItems[i]);\r
+ private WellknownClassJudgeRule createOrUpdateRule(WellknownClassJudgeRule rule){\r
+ JTextField text = new JTextField();\r
+ text.setOpaque(true);\r
+ Utility.decorateJComponent(text, "addwellknown.newrule.pattern");\r
+ JCheckBox excludeCheck = new JCheckBox(Messages.getString("addwellknown.newrule.exclude.label"), false);\r
+ Utility.decorateJComponent(excludeCheck, "addwellknown.newrule.exclude");\r
+ JComboBox matchTypeComboBox = new JComboBox();\r
+ for(Map.Entry<String, String> entry: matchTypeMap.entrySet()){\r
+ matchTypeComboBox.addItem(entry.getValue());\r
+ }\r
+ JComboBox partTypeComboBox = new JComboBox();\r
+ for(Map.Entry<String, String> entry: partTypeMap.entrySet()){\r
+ partTypeComboBox.addItem(entry.getValue());\r
+ }\r
+ if(rule != null){\r
+ text.setText(rule.getPattern());\r
+ excludeCheck.setSelected(rule.isExclude());\r
+ matchTypeComboBox.setSelectedItem(matchTypeMap.get(rule.getMatchType().name()));\r
+ partTypeComboBox.setSelectedItem(partTypeMap.get(rule.getMatchPartType().name()));\r
+ }\r
+\r
+ JPanel panel = new JPanel(new BorderLayout());\r
+ panel.setOpaque(true);\r
+ JPanel centerPanel = new JPanel(new FlowLayout());\r
+\r
+ centerPanel.add(partTypeComboBox);\r
+ centerPanel.add(matchTypeComboBox);\r
+\r
+ panel.add(excludeCheck, BorderLayout.NORTH);\r
+ panel.add(centerPanel, BorderLayout.CENTER);\r
+ panel.add(text, BorderLayout.SOUTH);\r
+\r
+ int value = JOptionPane.showConfirmDialog(\r
+ stigmata, panel, Messages.getString("addwellknown.dialog.title"),\r
+ JOptionPane.OK_CANCEL_OPTION\r
+ );\r
+ if(value == JOptionPane.OK_OPTION){\r
+ String matchType = findType(matchTypeComboBox, matchTypeMap);\r
+ String partType = findType(partTypeComboBox, partTypeMap);\r
+ WellknownClassJudgeRule.MatchType match = null;\r
+ WellknownClassJudgeRule.MatchPartType part = null;\r
+ String pattern = text.getText();\r
+ boolean excludeFlag = excludeCheck.isSelected();\r
+\r
+ if(matchType != null && partType != null){\r
+ match = WellknownClassJudgeRule.MatchType.valueOf(matchType);\r
+ part = WellknownClassJudgeRule.MatchPartType.valueOf(partType);\r
}\r
- TableColumn column1 = sectionTable.getColumn(checkPartColumnIdentifier);\r
- column1.setCellEditor(new DefaultCellEditor(checkPartType));\r
- column1.setCellRenderer(new DefaultTableCellRenderer(){\r
- private static final long serialVersionUID = 923743563L;\r
-\r
- public void setValue(Object value){\r
- if(value instanceof Integer){\r
- int type = ((Integer)value).intValue();\r
- if(type == WellknownClassJudgeRule.FULLY_TYPE){\r
- setText(checkPartItems[0]);\r
- }\r
- else if(type == WellknownClassJudgeRule.PACKAGE_TYPE){\r
- setText(checkPartItems[1]);\r
- }\r
- else if(type == WellknownClassJudgeRule.CLASS_NAME_TYPE){\r
- setText(checkPartItems[2]);\r
- }\r
- else if(type == WellknownClassJudgeRule.EXCLUDE_TYPE){\r
- setText(checkPartItems[3]);\r
- }\r
- else{\r
- setText(value.toString());\r
- }\r
- }\r
- else{\r
- setText(value.toString());\r
- }\r
- }\r
- });\r
\r
- matchType = new JComboBox();\r
- final String[] matchTypeStrings = Messages.getStringArray("matchtype.items");\r
- for(int i = 0; i < matchTypeStrings.length; i++){\r
- matchType.addItem(matchTypeStrings[i]);\r
+ if(match != null && partType != null && pattern != null && !pattern.equals("")){\r
+ return new WellknownClassJudgeRule(pattern, match, part, excludeFlag);\r
}\r
- TableColumn column2 = sectionTable.getColumn(matchTypeColumnIdentifier);\r
- column2.setCellEditor(new DefaultCellEditor(matchType));\r
- column2.setCellRenderer(new DefaultTableCellRenderer(){\r
- private static final long serialVersionUID = 972356346L;\r
-\r
- public void setValue(Object value){\r
- if(value instanceof Integer){\r
- int type = ((Integer)value).intValue();\r
- if(type == WellknownClassJudgeRule.PREFIX_TYPE){\r
- setText(matchTypeStrings[0]);\r
- }\r
- else if(type == WellknownClassJudgeRule.SUFFIX_TYPE){\r
- setText(matchTypeStrings[1]);\r
- }\r
- else if(type == WellknownClassJudgeRule.MATCH_TYPE){\r
- setText(matchTypeStrings[2]);\r
- }\r
- else{\r
- setText(value.toString());\r
- }\r
- }\r
- else{\r
- setText(value.toString());\r
- }\r
- }\r
- });\r
}\r
- return sectionTable;\r
+ return null;\r
}\r
-\r
}\r
\r
private void exportWellknownClasses(PrintWriter out) throws IOException{\r
out.println(" <wellknown-classes>");\r
- for(WellknownClassJudgeRule rule: environment.getWellknownClassManager().getSections()){\r
- int partType = rule.getMatchPartType();\r
- int match = rule.getMatchType();\r
- String value = rule.getName();\r
+ for(WellknownClassJudgeRule rule: environment.getWellknownClassManager()){\r
+ String value = rule.getPattern();\r
String tag;\r
String matchtag;\r
- if(partType == WellknownClassJudgeRule.CLASS_NAME_TYPE) tag = "class-name";\r
- else if(partType == WellknownClassJudgeRule.EXCLUDE_TYPE) tag = "exclude";\r
- else if(partType == WellknownClassJudgeRule.FULLY_TYPE) tag = "fully-name";\r
- else if(partType == WellknownClassJudgeRule.PACKAGE_TYPE) tag = "package";\r
- else throw new InternalError("unknown part type: " + partType);\r
-\r
- if(match == WellknownClassJudgeRule.MATCH_TYPE) matchtag = "match";\r
- else if(match == WellknownClassJudgeRule.PREFIX_TYPE) matchtag = "prefix";\r
- else if(match == WellknownClassJudgeRule.SUFFIX_TYPE) matchtag = "suffix";\r
- else throw new InternalError("unknown match type: " + match);\r
+ switch(rule.getMatchPartType()){\r
+ case CLASS_NAME:\r
+ tag = "class-name";\r
+ break;\r
+ case FULLY_NAME:\r
+ tag = "fully-name";\r
+ break;\r
+ case PACKAGE_NAME:\r
+ tag = "package-name";\r
+ break;\r
+ default:\r
+ throw new InternalError("unknown part type: " + rule.getMatchPartType());\r
+ }\r
+ switch(rule.getMatchType()){\r
+ case EXACT:\r
+ matchtag = "match";\r
+ break;\r
+ case NOT_MATCH:\r
+ matchtag = "not-match";\r
+ break;\r
+ case PREFIX:\r
+ matchtag = "prefix";\r
+ break;\r
+ case SUFFIX:\r
+ matchtag = "suffix";\r
+ break;\r
+ default:\r
+ throw new InternalError("unknown match type: " + rule.getMatchType());\r
+ }\r
\r
- out.printf(" <%s><%s>%s</%s></%s>%n", tag, matchtag, value, matchtag, tag);\r
+ out.print(" ");\r
+ if(rule.isExclude()) out.print("<exclude>");\r
+ out.printf("<%s><%s>%s</%s></%s>", tag, matchtag, value, matchtag, tag);\r
+ if(rule.isExclude()) out.print("</exclude>");\r
+ out.println();\r
}\r
out.println(" </wellknown-classes>");\r
}\r
private BirthmarkService service;\r
private ComparisonPairFilterSet filter;\r
private Part part;\r
- private int wellknownType = 0;\r
- private int patternType = 0;\r
+ private boolean exclude;\r
+ private WellknownClassJudgeRule.MatchType matchType;\r
+ private WellknownClassJudgeRule.MatchPartType partType;\r
private String qname;\r
private String key;\r
private String filterType, filterCriterion, attributeName;\r
\r
@Override\r
public void startElement(String uri, String localName, String qname,\r
- Attributes attributes) throws SAXException{\r
+ Attributes attributes) throws SAXException{\r
this.qname = qname;\r
\r
if(qname.equals("wellknown-classes")){\r
}\r
else if(part == Part.WELLKNOWN_CLASSES){\r
if(qname.equals("exclude")){\r
- wellknownType = WellknownClassJudgeRule.EXCLUDE_TYPE;\r
+ exclude = true;\r
}\r
- else if(qname.equals("package")){\r
- wellknownType = WellknownClassJudgeRule.PACKAGE_TYPE;\r
+ else if(qname.equals("package-name")){\r
+ partType = WellknownClassJudgeRule.MatchPartType.PACKAGE_NAME;\r
}\r
else if(qname.equals("class-name")){\r
- wellknownType = WellknownClassJudgeRule.CLASS_NAME_TYPE;\r
+ partType = WellknownClassJudgeRule.MatchPartType.CLASS_NAME;\r
}\r
else if(qname.equals("fully-name")){\r
- wellknownType = WellknownClassJudgeRule.FULLY_TYPE;\r
+ partType = WellknownClassJudgeRule.MatchPartType.FULLY_NAME;\r
}\r
else if(qname.equals("suffix")){\r
- patternType = WellknownClassJudgeRule.SUFFIX_TYPE;\r
+ matchType = WellknownClassJudgeRule.MatchType.SUFFIX;\r
}\r
else if(qname.equals("prefix")){\r
- patternType = WellknownClassJudgeRule.PREFIX_TYPE;\r
+ matchType = WellknownClassJudgeRule.MatchType.PREFIX;\r
}\r
else if(qname.equals("match")){\r
- patternType = WellknownClassJudgeRule.MATCH_TYPE;\r
+ matchType = WellknownClassJudgeRule.MatchType.EXACT;\r
+ }\r
+ else if(qname.equals("not-match")){\r
+ matchType = WellknownClassJudgeRule.MatchType.NOT_MATCH;\r
}\r
}\r
}\r
\r
@Override\r
- public void characters(char[] data, int offset, int length)\r
- throws SAXException{\r
+ public void characters(char[] data, int offset, int length) throws SAXException{\r
String value = new String(data, offset, length).trim();\r
\r
if(value.length() > 0){\r
}\r
}\r
else if(part == Part.WELLKNOWN_CLASSES\r
- && (qname.equals("suffix") || qname.equals("prefix") || qname\r
- .equals("match"))){\r
- manager.add(new WellknownClassJudgeRule(value,\r
- wellknownType | patternType));\r
+ && (qname.equals("suffix") || qname.equals("prefix") || qname.equals("match"))){\r
+ manager.add(new WellknownClassJudgeRule(value, matchType, partType, exclude));\r
+ exclude = false;\r
}\r
else if(part == Part.CLASSPATH && qname.equals("classpath")){\r
try{\r
--- /dev/null
+package jp.naist.se.stigmata.utils;
+
+/*
+ * $Id$
+ */
+
+import java.io.Serializable;
+
+/**
+ *
+ * @author Haruaki Tamada
+ * @version $Revision$ $Date$
+ */
+class Names implements Serializable{
+ private static final long serialVersionUID = 1911603124143509407L;
+ private final String fullyName;
+ private String className;
+ private String packageName;
+
+ public Names(final String fullyName){
+ this.fullyName = fullyName.replace('/', '.');
+ }
+
+ public String getFullyName(){
+ return fullyName;
+ }
+
+ public String getClassName(){
+ if(className == null){
+ generateClassAndPackageName();
+ }
+ return className;
+ }
+
+ public String getPackageName(){
+ if(packageName == null){
+ generateClassAndPackageName();
+ }
+ return packageName;
+ }
+
+ private void generateClassAndPackageName(){
+ final int index = fullyName.lastIndexOf('.');
+ this.className = fullyName.substring(index + 1);
+ this.packageName = "";
+ if(index > 0){
+ packageName = fullyName.substring(0, index - 1);
+ }
+ }
+}
* @author Haruaki TAMADA
* @version $Revision$ $Date$
*/
-public class WellknownClassJudgeRule{
- public static final int PREFIX_TYPE = 1;
-
- public static final int SUFFIX_TYPE = 2;
-
- public static final int MATCH_TYPE = 4;
-
- public static final int FULLY_TYPE = 0x10;
-
- public static final int PACKAGE_TYPE = 0x20;
-
- public static final int CLASS_NAME_TYPE = 0x40;
-
- public static final int EXCLUDE_TYPE = 0x80;
-
- private int type;
-
- private String name;
-
- public WellknownClassJudgeRule(String name, int type){
- this.name = name;
- this.type = type;
+public final class WellknownClassJudgeRule{
+ public enum MatchType{
+ PREFIX, SUFFIX, EXACT, NOT_MATCH,
+ };
+ public enum MatchPartType{
+ FULLY_NAME, PACKAGE_NAME, CLASS_NAME,
+ };
+
+ private MatchType matchType;
+ private MatchPartType partType;
+ private boolean excludeFlag;
+
+ private String pattern;
+
+ public WellknownClassJudgeRule(String pattern, MatchType matchType, MatchPartType partType){
+ this(pattern, matchType, partType, false);
}
- public boolean isExcludeType(){
- return getMatchPartType() == EXCLUDE_TYPE;
+ public WellknownClassJudgeRule(String pattern, MatchType matchType, MatchPartType partType, boolean excludeFlag){
+ this.pattern = pattern;
+ this.matchType = matchType;
+ this.partType = partType;
+ this.excludeFlag = excludeFlag;
}
- public boolean isFullyType(){
- return getMatchPartType() == FULLY_TYPE;
+ public void setExclude(boolean excludeFlag){
+ this.excludeFlag = excludeFlag;
}
- public boolean isPackageType(){
- return getMatchPartType() == PACKAGE_TYPE;
+ public boolean isExclude(){
+ return excludeFlag;
}
- public boolean isClassNameType(){
- return getMatchPartType() == CLASS_NAME_TYPE;
+ public String getPattern(){
+ return pattern;
}
- public int getMatchPartType(){
- return getType() & 0xf0;
+ public MatchType getMatchType(){
+ return matchType;
}
- public int getMatchType(){
- return getType() & 0xf;
+ public MatchPartType getMatchPartType(){
+ return partType;
}
- public int getType(){
- return type;
+ public int hashCode(){
+ int m = getMatchType().hashCode();
+ int p = getMatchPartType().hashCode();
+ int s = getPattern().hashCode();
+
+ return m + p + s;
}
- public String getName(){
- return name;
+ public boolean equals(Object o){
+ if(o instanceof WellknownClassJudgeRule){
+ WellknownClassJudgeRule wcjr = (WellknownClassJudgeRule)o;
+ return getPattern().equals(wcjr.getPattern())
+ && getMatchPartType() == wcjr.getMatchPartType()
+ && getMatchType() == wcjr.getMatchType();
+ }
+ return false;
}
public String toString(){
+ String string = null;
switch(getMatchType()){
- case PREFIX_TYPE:
- return "<prefix>" + getName() + "</prefix>";
- case SUFFIX_TYPE:
- return "<suffix>" + getName() + "</suffix>";
- case MATCH_TYPE:
- return "<match>" + getName() + "</match>";
+ case PREFIX:
+ string = String.format("<prefix>%s</prefix>", getPattern());
+ break;
+ case SUFFIX:
+ string = String.format("<suffix>%s</suffix>", getPattern());
+ break;
+ case EXACT:
+ string = String.format("<match>%s</match>", getPattern());
+ break;
+ case NOT_MATCH:
+ string = String.format("<not-match>%s</not-match>", getPattern());
+ break;
+ }
+ switch(getMatchPartType()){
+ case CLASS_NAME:
+ string = String.format("<class-name>%s</class-name>", string);
+ break;
+ case FULLY_NAME:
+ string = String.format("<fully-name>%s</fully-name>", string);
+ break;
+ case PACKAGE_NAME:
+ string = String.format("<package-name>%s</package-name>", string);
+ break;
+ }
+ if(isExclude()){
+ string = "<exclude>" + string + "</exclude>";
}
- return null;
+ return string;
}
}
import org.objectweb.asm.Opcodes;
+import jp.naist.se.stigmata.utils.WellknownClassJudgeRule.MatchType;
+import jp.naist.se.stigmata.utils.WellknownClassJudgeRule.MatchPartType;
+
/**
* Managing wellknown class checking rule.
*
* @author Haruaki TAMADA
* @version $Revision$ $Date$
*/
-public class WellknownClassManager{
- public static final int FULLY_PREFIX_TYPE = WellknownClassJudgeRule.FULLY_TYPE | WellknownClassJudgeRule.PREFIX_TYPE;
- public static final int FULLY_SUFFIX_TYPE = WellknownClassJudgeRule.FULLY_TYPE | WellknownClassJudgeRule.SUFFIX_TYPE;
- public static final int FULLY_MATCH_TYPE = WellknownClassJudgeRule.FULLY_TYPE | WellknownClassJudgeRule.MATCH_TYPE;
- public static final int PACKAGE_PREFIX_TYPE = WellknownClassJudgeRule.PACKAGE_TYPE | WellknownClassJudgeRule.PREFIX_TYPE;
- public static final int PACKAGE_SUFFIX_TYPE = WellknownClassJudgeRule.PACKAGE_TYPE | WellknownClassJudgeRule.SUFFIX_TYPE;
- public static final int PACKAGE_MATCH_TYPE = WellknownClassJudgeRule.PACKAGE_TYPE | WellknownClassJudgeRule.MATCH_TYPE;
- public static final int CLASS_NAME_PREFIX_TYPE = WellknownClassJudgeRule.CLASS_NAME_TYPE | WellknownClassJudgeRule.PREFIX_TYPE;
- public static final int CLASS_NAME_SUFFIX_TYPE = WellknownClassJudgeRule.CLASS_NAME_TYPE | WellknownClassJudgeRule.SUFFIX_TYPE;
- public static final int CLASS_NAME_MATCH_TYPE = WellknownClassJudgeRule.CLASS_NAME_TYPE | WellknownClassJudgeRule.MATCH_TYPE;
-
- private List<WellknownClassJudgeRule> systemClassesList = new ArrayList<WellknownClassJudgeRule>();
- private List<WellknownClassJudgeRule> excludes = new ArrayList<WellknownClassJudgeRule>();
+public class WellknownClassManager implements Iterable<WellknownClassJudgeRule>{
+ private List<WellknownClassJudgeRule> rules = new ArrayList<WellknownClassJudgeRule>();
public WellknownClassManager(){
}
public WellknownClassManager(WellknownClassManager manager){
- systemClassesList = new ArrayList<WellknownClassJudgeRule>(manager.systemClassesList);
- excludes = new ArrayList<WellknownClassJudgeRule>(manager.excludes);
+ rules = new ArrayList<WellknownClassJudgeRule>(manager.rules);
}
- public void remove(String value, int type){
- int index = -1;
- for(int i = 0; i < systemClassesList.size(); i++){
- WellknownClassJudgeRule section = (WellknownClassJudgeRule)systemClassesList.get(i);
- if(section.getName().equals(value) && section.getType() == type){
- index = i;
- break;
- }
- }
- systemClassesList.remove(index);
+ public void remove(WellknownClassJudgeRule rule){
+ rules.remove(rule);
+ }
+
+ public void remove(String value, MatchType matchType, MatchPartType partType){
+ remove(new WellknownClassJudgeRule(value, matchType, partType));
}
public void clear(){
- systemClassesList.clear();
- excludes.clear();
+ rules.clear();
}
- public WellknownClassJudgeRule[] getSections(){
- List<WellknownClassJudgeRule> sections = new ArrayList<WellknownClassJudgeRule>();
- sections.addAll(excludes);
- sections.addAll(systemClassesList);
- return sections.toArray(new WellknownClassJudgeRule[sections.size()]);
+ public synchronized Iterator<WellknownClassJudgeRule> iterator(){
+ List<WellknownClassJudgeRule> copiedRules = new ArrayList<WellknownClassJudgeRule>(rules);
+ return copiedRules.iterator();
}
- public void add(WellknownClassJudgeRule section){
- if(section.isExcludeType()){
- excludes.add(section);
- }
- else{
- systemClassesList.add(section);
- }
+ public synchronized WellknownClassJudgeRule[] getRules(){
+ return rules.toArray(new WellknownClassJudgeRule[rules.size()]);
}
- private boolean checkSystemClass(String className){
- String fully = className.replace('/', '.');
- int index = className.lastIndexOf('.');
- String cn = className.substring(index + 1);
- String pn = "";
- if(index > 0){
- pn = fully.substring(0, index - 1);
+ public void add(WellknownClassJudgeRule rule){
+ if(!rules.contains(rule)){
+ rules.add(rule);
}
+ }
- if(isExcludes(fully)){
+ private boolean checkSystemClass(String className){
+ Names names = new Names(className);
+ if(isMatch(names, true)){
return false;
}
-
- for(Iterator<WellknownClassJudgeRule> i = systemClassesList.iterator(); i.hasNext(); ){
- WellknownClassJudgeRule section = i.next();
- String target = fully;
- if(section.isClassNameType()){
- target = cn;
- }
- else if(section.isPackageType()){
- target = pn;
- }
- switch(section.getMatchType()){
- case WellknownClassJudgeRule.PREFIX_TYPE:
- if(target.startsWith(section.getName())){
- return true;
- }
- break;
- case WellknownClassJudgeRule.SUFFIX_TYPE:
- if(target.endsWith(section.getName())){
- return true;
- }
- break;
- case WellknownClassJudgeRule.MATCH_TYPE:
- if(target.equals(section.getName())){
- return true;
- }
- break;
- }
- }
- return false;
+ return isMatch(names, false);
}
- private boolean isExcludes(String fully){
- for(Iterator<WellknownClassJudgeRule> i = excludes.iterator(); i.hasNext(); ){
+ private boolean isMatch(Names names, boolean excludeFlag){
+ for(Iterator<WellknownClassJudgeRule> i = rules.iterator(); i.hasNext(); ){
WellknownClassJudgeRule s = i.next();
- switch(s.getMatchType()){
- case WellknownClassJudgeRule.PREFIX_TYPE:
- if(fully.startsWith(s.getName())){
- return true;
+ if(s.isExclude() == excludeFlag){
+ boolean flag = false;
+ String partName = names.getFullyName();
+ if(s.getMatchPartType() == MatchPartType.CLASS_NAME){
+ partName = names.getClassName();
+ }
+ else if(s.getMatchPartType() == MatchPartType.PACKAGE_NAME){
+ partName = names.getPackageName();
}
- break;
- case WellknownClassJudgeRule.SUFFIX_TYPE:
- if(fully.endsWith(s.getName())){
- return true;
+ switch(s.getMatchType()){
+ case PREFIX:
+ flag = partName.startsWith(s.getPattern());
+ break;
+ case SUFFIX:
+ flag = partName.endsWith(s.getPattern());
+ break;
+ case EXACT:
+ flag = partName.equals(s.getPattern());
+ break;
+ case NOT_MATCH:
+ flag = !partName.equals(s.getPattern());
+ break;
}
- break;
- case WellknownClassJudgeRule.MATCH_TYPE:
- if(fully.equals(s.getName())){
- return true;
+ if(flag){
+ return flag;
}
- break;
}
}
return false;
*/
private boolean checkSystemMethod(int access, String methodName, String signature){
if(methodName.equals("main")){
- return signature.equals("([Ljava/lang/String;)V") &&
- checkAccess(access, Opcodes.ACC_PUBLIC);
+ return signature.equals("([Ljava/lang/String;)V")
+ && checkAccess(access, Opcodes.ACC_PUBLIC);
}
else if(methodName.equals("<clinit>")){
- return signature.equals("()V") &&
- checkAccess(access, Opcodes.ACC_STATIC);
+ return signature.equals("()V")
+ && checkAccess(access, Opcodes.ACC_STATIC);
}
else if(methodName.equals("<init>")){
return !checkAccess(access, Opcodes.ACC_STATIC);
<!ELEMENT criterion (#PCDATA)>\r
<!ELEMENT filter-type (#PCDATA)>\r
\r
-<!ELEMENT exclude (suffix|prefix|match)>\r
-<!ELEMENT package (suffix|prefix|match)>\r
-<!ELEMENT class-name (suffix|prefix|match)>\r
-<!ELEMENT fully-name (suffix|prefix|match)>\r
+<!ELEMENT package (suffix|prefix|match|not-match)>\r
+<!ELEMENT class-name (suffix|prefix|match|not-match)>\r
+<!ELEMENT fully-name (suffix|prefix|match|not-match)>\r
\r
+<!ELEMENT exclude (package|class-name|fully-name)>\r
<!ELEMENT wellknown-classes ((exclude|package|class-name|fully-name)*)>\r
\r
<!ELEMENT property (name,value)>\r
<zeroOrMore>
<choice>
<ref name="exclude"/>
- <ref name="package"/>
- <ref name="class-name"/>
- <ref name="fully-name"/>
+ <ref name="judge-rule"/>
</choice>
</zeroOrMore>
</element>
<define name="exclude">
<element name="exclude">
- <ref name="match-type"/>
+ <ref name="judge-rule"/>
</element>
</define>
+
+ <define name="judge-rule">
+ <choice>
+ <ref name="package-name"/>
+ <ref name="class-name"/>
+ <ref name="fully-name"/>
+ </choice>
+ </define>
<define name="package">
<element name="package">
<ref name="match-type"/>
<ref name="prefix"/>
<ref name="match"/>
<ref name="suffix"/>
+ <ref name="not-match"/>
</choice>
</define>
<data type="string"/>
</element>
</define>
+ <define name="not-match">
+ <element name="not-match">
+ <data type="string"/>
+ </element>
+ </define>
<define name="suffix">
<element name="suffix">
<data type="string"/>
newframe.menuitem.tooltip=Create New Frame\r
newframe.menuitem.icon=application_add.png\r
\r
-exportsetting.menuitem.label=Export settings...\r
+savesetting.menuitem.label=Save settings\r
+savesetting.menuitem.tooltip=Save current settings\r
+savesetting.menuitem.icon=page_save.png\r
+\r
+exportsetting.menuitem.label=Export settings as...\r
exportsetting.menuitem.tooltip=Export settings of control panel.\r
-exportsetting.menuitem.icon=page_save.png\r
+exportsetting.menuitem.icon=page_go.png\r
\r
export.extensions=xml\r
export.description=Store stigmata settings to {0} file\r
# WellknownClassesSettingsPane\r
################################################\r
addwellknown.button.label=Add...\r
-addwellknown.button.tooltip=Add well-known class check rule\r
+addwellknown.button.tooltip=Add a new well-known class check rule\r
addwellknown.button.icon=cog_add.png\r
addwellknown.dialog.title=New Wellknown class rule\r
\r
+addwellknown.newrule.pattern.tooltip=A pattern of new rule\r
+addwellknown.newrule.pattern.border=New rule pattern\r
+addwellknown.newrule.exclude.label=Exclude rule\r
+addwellknown.newrule.exclude.tooltip=If this check box is checked, specified rule is exclude pattern\r
+\r
+updatewellknown.button.label=Update...\r
+updatewellknown.button.tooltip=Update the selected well-known class check rule\r
+updatewellknown.button.icon=cog_edit.png\r
+\r
+matchtype.PREFIX=starts with\r
+matchtype.SUFFIX=ends with\r
+matchtype.EXACT=exact matches with\r
+matchtype.NOT_MATCH=not matches with\r
+\r
+matchparttype.FULLY_NAME=Fully class name\r
+matchparttype.CLASS_NAME=Class name (exclude package name)\r
+matchparttype.PACKAGE_NAME=Package name (exclude class name)\r
+\r
removewellknown.button.label=Remove...\r
removewellknown.button.tooltip=Remove selected check rule\r
removewellknown.button.icon=cog_delete.png\r
newframe.menuitem.label=\90V\8bK\83t\83\8c\81[\83\80\r
newframe.menuitem.tooltip=\90V\82µ\82¢\83t\83\8c\81[\83\80\82ð\8dì\90¬\82µ\82Ü\82·\r
\r
-exportsetting.menuitem.label=\90Ý\92è\82ð\95Û\91¶...\r
-exportsetting.menuitem.tooltip=\90Ý\92è\82ðXML\83t\83@\83C\83\8b\82É\95Û\91¶\82µ\82Ü\82·\81D\r
+savesetting.menuitem.label=\90Ý\92è\82ð\95Û\91¶\r
+savesetting.menuitem.tooltip=\8c»\8dÝ\82Ì\90Ý\92è\82ð\95Û\91¶\82µ\82Ü\82·\r
+\r
+exportsetting.menuitem.label=\90Ý\92è\82ð\95Ê\96¼\82Å\95Û\91¶...\r
+exportsetting.menuitem.tooltip=\90Ý\92è\82ðXML\83t\83@\83C\83\8b\82É\95Û\91¶\82µ\82Ü\82·\r
export.description=\90Ý\92è\83t\83@\83C\83\8b ({0})\r
\r
closetab.menuitem.label=\83^\83u\82ð\95Â\82¶\82é\r
addwellknown.button.tooltip=\8aù\92m\82Ì\83N\83\89\83X\94»\92è\83\8b\81[\83\8b\82ð\92Ç\89Á\82µ\82Ü\82·\r
addwellknown.dialog.title=\90V\8bK: \8aù\92m\82Ì\83N\83\89\83X\94»\92è\83\8b\81[\83\8b\r
\r
+addwellknown.newrule.pattern.tooltip=\90V\8bK\83\8b\81[\83\8b\82Ì\94»\92è\95¶\8e\9a\97ñ\83p\83^\81[\83\93\r
+addwellknown.newrule.pattern.border=\83p\83^\81[\83\93\r
+addwellknown.newrule.exclude.label=\8f\9c\8aO\83\8b\81[\83\8b\r
+addwellknown.newrule.exclude.tooltip=\83`\83F\83b\83N\82ª\93ü\82ê\82ç\82ê\82Ä\82¢\82é\8fê\8d\87\81C\88È\89º\82Å\8ew\92è\82·\82é\83\8b\81[\83\8b\82Í\8aù\92m\82Ì\83N\83\89\83X\94»\92è\83\8b\81[\83\8b\82©\82ç\8f\9c\8aO\82³\82ê\82é\83\8b\81[\83\8b\82Æ\82µ\82Ä\88µ\82í\82ê\82Ü\82·\r
+\r
+updatewellknown.button.label=\8dX\90V...\r
+updatewellknown.button.tooltip=\91I\91ð\92\86\82Ì\83\8b\81[\83\8b\82ð\8dX\90V\82µ\82Ü\82·\r
+\r
+matchparttype.FULLY_NAME=\83N\83\89\83X\82Ì\8a®\91S\8fC\8fü\96¼\82ª\r
+matchparttype.CLASS_NAME=\83p\83b\83P\81[\83W\96¼\82ð\8f\9c\82\83N\83\89\83X\96¼\82ª\r
+matchparttype.PACKAGE_NAME=\83p\83b\83P\81[\83W\96¼\82ª\r
+\r
+matchtype.PREFIX=\8e\9f\82Ì\83p\83^\81[\83\93\82Å\8en\82Ü\82Á\82Ä\82¢\82é\r
+matchtype.SUFFIX=\8e\9f\82Ì\83p\83^\81[\83\93\82Å\8fI\82í\82Á\82Ä\82¢\82é\r
+matchtype.EXACT=\8e\9f\82Ì\83p\83^\81[\83\93\82Æ\8a®\91S\82É\88ê\92v\82µ\82Ä\82¢\82é\r
+matchtype.NOT_MATCH=\8e\9f\82Ì\83p\83^\81[\83\93\82Æ\88ê\92v\82µ\82Ä\82¢\82È\82¢\r
+\r
removewellknown.button.label=\8dí\8f\9c...\r
removewellknown.button.tooltip=\8ew\92è\82³\82ê\82½\8aù\92m\82Ì\83N\83\89\83X\94»\92è\83\8b\81[\83\8b\82ð\8dí\8f\9c\82µ\82Ü\82·\r
\r
Those names are excluded from wellknown classes, even if
following parts define the name is contain wellknown classes.
¤³¤ÎÃæ¤Ë´Þ¤Þ¤ì¤ë¤â¤Î¤Ï¾¤Ç¤¤¤¯¤é wellknown ¤ÈÀßÄꤵ¤ì¤Æ¤¤¤Æ¤â̵»ë¤¹¤ë¡¥
- »ØÄêÊýË¡¤Ï fully-names ¤ÈƱ¤¸¡¥
-->
- <exclude><suffix>Exception</suffix></exclude>
- <exclude><suffix>Error</suffix></exclude>
- <exclude><match>java.lang.Throwable</match></exclude>
- <exclude><match>java.lang.ThreadDeath</match></exclude>
+ <exclude><fully-name><suffix>Exception</suffix></fully-name></exclude>
+ <exclude><fully-name><suffix>Error</suffix></fully-name></exclude>
+ <exclude><fully-name><match>java.lang.Throwable</match></fully-name></exclude>
+ <exclude><fully-name><match>java.lang.ThreadDeath</match></fully-name></exclude>
<!-- Package names includes JDK 1.5 -->
- <package><prefix>java</prefix></package>
- <package><prefix>javax</prefix></package>
- <package><prefix>org.omg</prefix></package>
- <package><prefix>org.xml</prefix></package>
- <package><prefix>org.w3c</prefix></package>
- <package><prefix>org.ietf</prefix></package>
+ <package-name><prefix>java</prefix></package-name>
+ <package-name><prefix>javax</prefix></package-name>
+ <package-name><prefix>org.omg</prefix></package-name>
+ <package-name><prefix>org.xml</prefix></package-name>
+ <package-name><prefix>org.w3c</prefix></package-name>
+ <package-name><prefix>org.ietf</prefix></package-name>
<!-- ¤½¤Î¾¡¤¤è¤¯»È¤ï¤ì¤Æ¤¤¤½¤¦¤Ê¥Ñ¥Ã¥±¡¼¥¸ -->
- <package><prefix>org.gnu</prefix></package>
- <package><prefix>com.apple</prefix></package>
- <package><prefix>pnuts</prefix></package>
- <package><prefix>org.eclipse</prefix></package>
- <package><prefix>com.sun</prefix></package>
- <package><prefix>sun</prefix></package>
- <package><prefix>junit</prefix></package>
- <package><prefix>org.apache</prefix></package>
+ <package-name><prefix>org.gnu</prefix></package-name>
+ <package-name><prefix>com.apple</prefix></package-name>
+ <package-name><prefix>pnuts</prefix></package-name>
+ <package-name><prefix>org.eclipse</prefix></package-name>
+ <package-name><prefix>com.sun</prefix></package-name>
+ <package-name><prefix>sun</prefix></package-name>
+ <package-name><prefix>junit</prefix></package-name>
+ <package-name><prefix>org.apache</prefix></package-name>
<class-name><suffix>Test</suffix></class-name>
<!--
OSDN Git Service
