/core/src/com/bluemarsh/jswat/core/util/Names.java

  1/*
  2 * The contents of this file are subject to the terms of the Common Development
  3 * and Distribution License (the License). You may not use this file except in
  4 * compliance with the License.
  5 *
  6 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
  7 * or http://www.netbeans.org/cddl.txt.
  8 *
  9 * When distributing Covered Code, include this CDDL Header Notice in each file
 10 * and include the License file at http://www.netbeans.org/cddl.txt.
 11 * If applicable, add the following below the CDDL Header, with the fields
 12 * enclosed by brackets [] replaced by your own identifying information:
 13 * "Portions Copyrighted [year] [name of copyright owner]"
 14 *
 15 * The Original Software is the JSwat Core Module. The Initial Developer of the
 16 * Software is Nathan L. Fiedler. Portions created by Nathan L. Fiedler
 17 * are Copyright (C) 2003-2010. All Rights Reserved.
 18 *
 19 * Contributor(s): Nathan L. Fiedler.
 20 *
 21 * $Id: Names.java 285 2010-11-20 23:56:08Z nathanfiedler $
 22 */
 23package com.bluemarsh.jswat.core.util;
 24
 25import com.bluemarsh.jswat.core.CoreSettings;
 26import java.io.File;
 27import java.util.StringTokenizer;
 28
 29/**
 30 * Class defining utility methods for class names and element names.
 31 *
 32 * @author  Nathan Fiedler
 33 */
 34public class Names {
 35
 36    /**
 37     * None shall instantiate us.
 38     */
 39    private Names() {
 40    }
 41
 42    /**
 43     * Turn the package name into a file path using simple character
 44     * substitution. Strips off any inner-class names before making the
 45     * conversion. The source file extension from CoreSettings will be
 46     * added to the end of the return value.
 47     *
 48     * <p>Note that this class may have come from a source file that
 49     * had some other name, in which case the return value will be
 50     * meaningless. The ideal solution is to use the appropriate methods
 51     * of Location and ReferenceType to get the true source name and
 52     * then call the two-argument form of this method.</p>
 53     *
 54     * @param  clsname  fully-qualified name of the class, possibly
 55     *                  including an inner-class specification.
 56     * @return  path and filename of a source file.
 57     */
 58    public static String classnameToFilename(String clsname) {
 59        String cname = clsname;
 60        int idx = cname.indexOf('$');
 61        if (idx > 0) {
 62            cname = cname.substring(0, idx);
 63        }
 64        cname = cname.replace('.', File.separatorChar);
 65        CoreSettings cs = CoreSettings.getDefault();
 66        cname += cs.getSourceExtension();
 67        return cname;
 68    }
 69
 70    /**
 71     * Converts a class name, with the given source file name, into a path
 72     * and filename of the source file for the class.
 73     *
 74     * @param  clsname  fully-qualified name of class.
 75     * @param  srcname  name of source file containing class.
 76     * @return  path and filename of source file.
 77     */
 78    public static String classnameToFilename(String clsname, String srcname) {
 79        String filename = classnameToFilename(clsname);
 80        int lastbit = filename.lastIndexOf(File.separatorChar);
 81        if (lastbit > -1) {
 82            filename = filename.substring(0, lastbit);
 83            filename = filename + File.separator + srcname;
 84        } else {
 85            // Class without a path, just use the source name.
 86            filename = srcname;
 87        }
 88        return filename;
 89    }
 90
 91    /**
 92     * Returns just the package name of the class.
 93     *
 94     * @param  name  fully-qualified class name.
 95     * @return  package name (may be empty), or null if name is null.
 96     */
 97    public static String getPackageName(String name) {
 98        if (name == null) {
 99            return null;
100        }
101        int lastdot = name.lastIndexOf('.');
102        if (lastdot > 0) {
103            return name.substring(0, lastdot);
104        } else {
105            return "";
106        }
107    }
108
109    /**
110     * Returns just the name of the class, without the package name.
111     *
112     * @param  name  fully-qualified class name.
113     * @return  just the class name, or null if name is null.
114     */
115    public static String getShortClassName(String name) {
116        if (name == null) {
117            return null;
118        }
119        int lastdot = name.lastIndexOf('.');
120        if (lastdot > 0) {
121            return name.substring(lastdot + 1);
122        } else {
123            return name;
124        }
125    }
126
127    /**
128     * Test whether a given string is a valid Java identifier. Unlike
129     * org.openide.util.Utilities, this does not consider keywords to
130     * be valid identifiers (because they are not identifiers).
131     *
132     * @param  id  String which should be checked.
133     * @return  true if a valid identifier, false otherwise.
134     */
135    public static boolean isJavaIdentifier(String id) {
136        if (id == null) {
137            return false;
138        }
139        if (id.trim().isEmpty()) {
140            return false;
141        }
142        if (!Character.isJavaIdentifierStart(id.charAt(0))) {
143            return false;
144        }
145        for (int ii = 1; ii < id.length(); ii++) {
146            if (!Character.isJavaIdentifierPart(id.charAt(ii))) {
147                return false;
148            }
149        }
150        return true;
151    }
152
153    /**
154     * Determine if the given string is a valid method identifier.
155     *
156     * @param  s  string to validate.
157     * @return  true if string is a valid method identifier.
158     */
159    public static boolean isMethodIdentifier(String s) {
160        if (s == null || s.trim().isEmpty()) {
161            return false;
162        }
163        return isJavaIdentifier(s) || s.equals("<init>") || s.equals("<clinit>");
164    }
165
166    /**
167     * Determines if the given String represents a valid class name.
168     * The string is split into tokens delimited by a period (.). The
169     * first or last token may be an asterisk (*) to represent a
170     * wild-card for the purpose of matching multiple classes (for use
171     * in setting breakpoints), if allowWild is true.
172     *
173     * @param  s          String to validate.
174     * @param  allowWild  true to allow wildcards, false to treat as invalid.
175     * @return  true if name is valid, false otherwise.
176     */
177    public static boolean isValidClassname(String s, boolean allowWild) {
178        if (s == null || s.trim().isEmpty()) {
179            return false;
180        }
181        boolean valid = true;
182        StringTokenizer tokenizer = new StringTokenizer(s, ".");
183        int numTokens = tokenizer.countTokens();
184        int curToken = 0;
185        while (tokenizer.hasMoreTokens()) {
186            String token = tokenizer.nextToken();
187            curToken++;
188            if (allowWild && token.equals("*")) {
189                if (curToken == 1) {
190                    continue;
191                } else if (curToken == numTokens) {
192                    break;
193                }
194            }
195            if (!isJavaIdentifier(token)) {
196                valid = false;
197                break;
198            }
199        }
200        return valid;
201    }
202}