jdk-sandbox: comparison jdk/src/share/classes/javax/management/ObjectName.java

equal deleted inserted replaced

-:a9a142fcf1b5
+:bbc2d15aaf7a
 package javax.management;
 import com.sun.jmx.mbeanserver.GetPropertyAction;
 import com.sun.jmx.mbeanserver.Util;
+import com.sun.jmx.namespace.serial.JMXNamespaceContext;
 import java.io.IOException;
 import java.io.InvalidObjectException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.ObjectStreamField;
 */
 @SuppressWarnings("serial") // don't complain serialVersionUID not constant
 public class ObjectName implements Comparable<ObjectName>, QueryExp {
 /**
+* The sequence of characters used to separate name spaces in a name space
+* path.
+*
+* @see javax.management.namespace
+* @since 1.7
+**/
+public static final String NAMESPACE_SEPARATOR = "//";
+private static final int NAMESPACE_SEPARATOR_LENGTH =
+NAMESPACE_SEPARATOR.length();
+/**
 * A structure recording property structure and
 * proposing minimal services
 */
 private static class Property {
 }
 /**
 * Returns a key string for receiver key
 */
-String getKeyString(String name) {
+String getKeyString(String name, int offset) {
-return name.substring(_key_index, _key_index + _key_length);
+final int start = _key_index+offset;
+return name.substring(start, start + _key_length);
 }
 /**
 * Returns a value string for receiver key
 */
-String getValueString(String name) {
+String getValueString(String name, int offset) {
-int in_begin = _key_index + _key_length + 1;
+final int in_begin = _key_index + offset + _key_length + 1;
-int out_end = in_begin + _value_length;
+final int out_end = in_begin + _value_length;
 return name.substring(in_begin, out_end);
 }
 }
 /**
 * boolean that declares if this ObjectName contains a pattern on the
 * value of at least one key property
 */
 private transient boolean _property_value_pattern = false;
+private ObjectName(String newDomain, ObjectName aname)
+throws MalformedObjectNameException{
+copyToOtherDomain(newDomain,aname);
+}
+private void copyToOtherDomain(String domain, ObjectName aname)
+throws MalformedObjectNameException, NullPointerException {
+// The domain cannot be null
+if (domain == null)
+throw new NullPointerException("domain cannot be null");
+// The key property list cannot be null
+if (aname == null)
+throw new MalformedObjectNameException(
+"key property list cannot be empty");
+// checks domain validity. A side effect of this method is also to
+// set the _domain_pattern flag.
+if (!isDomain(domain))
+throw new MalformedObjectNameException("Invalid domain: " + domain);
+// init canonicalname
+_domain_length = domain.length();
+_canonicalName = (domain +
+aname._canonicalName.substring(aname._domain_length)).intern();
+_kp_array = aname._kp_array;
+_ca_array = aname._ca_array;
+_propertyList = aname._propertyList;
+_property_list_pattern = aname._property_list_pattern;
+_property_value_pattern = aname._property_value_pattern;
+// TODO remove this hack
+// if (toString().endsWith("//javax.management.service:type1=event_client_delegeate_mbean,type2=default")) {
+//    Thread.currentThread().dumpStack();
+//    throw new Error("************************ Gotcha!");
+//}
+}
 // Instance private fields <=======================================
 // Private fields <========================================
 _property_value_pattern = false;
 return;
 }
 // initialize parsing of the string
-char[] name_chars = name.toCharArray();
+final char[] name_chars = name.toCharArray();
-int len = name_chars.length;
+final int len = name_chars.length;
-char[] canonical_chars = new char[len]; // canonical form will be same
+final char[] canonical_chars = new char[len]; // canonical form will
-// length at most
+// be same length at most
 int cname_index = 0;
 int index = 0;
 char c, c1;
 // parses domain part
 "Invalid ending comma");
 } else in_index++;
 // we got the key and value part, prepare a property for this
 if (!value_pattern) {
-prop = new Property(key_index, key_length, value_length);
+prop = new Property(key_index-_domain_length,
+key_length, value_length);
 } else {
 _property_value_pattern = true;
-prop = new PatternProperty(key_index, key_length, value_length);
+prop = new PatternProperty(key_index-_domain_length,
+key_length, value_length);
 }
 key_name = name.substring(key_index, key_index + key_length);
 if (property_index == keys.length) {
 String[] tmp_string_array = new String[property_index + 10];
 keys[i] = key;
 sb.append("=");
 boolean value_pattern = checkValue(value);
 sb.append(value);
 if (!value_pattern) {
-prop = new Property(key_index,
+prop = new Property(key_index-_domain_length,
 key.length(),
 value.length());
 } else {
 _property_value_pattern = true;
-prop = new PatternProperty(key_index,
+prop = new PatternProperty(key_index-_domain_length,
 key.length(),
 value.length());
 }
 addProperty(prop, i, keys_map, key);
 i++;
 Property prop;
 for (int i = 0; i <= last_index; i++) {
 prop = _ca_array[i];
 // length of prop including '=' char
 prop_len = prop._key_length + prop._value_length + 1;
-System.arraycopy(specified_chars, prop._key_index,
+System.arraycopy(specified_chars, prop._key_index+_domain_length,
 canonical_chars, prop_index, prop_len);
-prop.setKeyIndex(prop_index);
+prop.setKeyIndex(prop_index-_domain_length);
 prop_index += prop_len;
 if (i != last_index) {
 canonical_chars[prop_index] = ',';
 prop_index++;
 }
 if (endKey < len) throw new
 MalformedObjectNameException("Invalid character in value: `" +
 k[endKey] + "'");
 }
-/*
-* Tests whether string s is matched by pattern p.
-* Supports "?", "*" each of which may be escaped with "\";
-* Not yet supported: internationalization; "\" inside brackets.<P>
-* Wildcard matching routine by Karl Heuer.  Public Domain.<P>
-*/
-private static boolean wildmatch(char[] s, char[] p, int si, int pi) {
-char c;
-final int slen = s.length;
-final int plen = p.length;
-while (pi < plen) { // While still string
-c = p[pi++];
-if (c == '?') {
-if (++si > slen) return false;
-} else if (c == '*') { // Wildcard
-if (pi >= plen) return true;
-do {
-if (wildmatch(s,p,si,pi)) return true;
-} while (++si < slen);
-return false;
-} else {
-if (si >= slen || c != s[si++]) return false;
-}
-}
-return (si == slen);
-}
 // Category : Internal utilities <==============================
 // Category : Internal accessors ------------------------------>
 //
 in.defaultReadObject();
 cn = (String)in.readObject();
 }
+final JMXNamespaceContext ctxt =
+JMXNamespaceContext.getDeserializationContext();
 try {
-construct(cn);
+construct(changeContext(ctxt,cn));
 } catch (NullPointerException e) {
+throw new InvalidObjectException(e.toString());
+} catch (IllegalArgumentException e) {
 throw new InvalidObjectException(e.toString());
 } catch (MalformedObjectNameException e) {
 throw new InvalidObjectException(e.toString());
 }
 }
+private String changeContext(JMXNamespaceContext context, String nameString) {
+final String old = context.prefixToRemove;
+final String nw  = context.prefixToAdd;
+final int ol = old.length();
+if (nameString.startsWith(NAMESPACE_SEPARATOR)) return nameString;
+if (ol>0) {
+if (!nameString.startsWith(old) ||
+!nameString.startsWith(NAMESPACE_SEPARATOR,ol))
+throw new IllegalArgumentException(
+"Serialized ObjectName does not start with " + old +
+": " + nameString);
+nameString = nameString.substring(ol+NAMESPACE_SEPARATOR_LENGTH);
+}
+if (!nw.equals("")) {
+nameString = nw + NAMESPACE_SEPARATOR + nameString;
+}
+// TODO remove this hack
+// if (nameString.endsWith("//javax.management.service:type1=event_client_delegeate_mbean,type2=default")) {
+//    System.err.println("old="+old+", nw="+nw);
+//    Thread.currentThread().dumpStack();
+//    throw new Error("************************ Gotcha!");
+// }
+return nameString;
+}
 /**
 * Serializes an {@link ObjectName} to an {@link ObjectOutputStream}.
 * @serialData <ul>
 *               <li>In the current serial form (value of property
 *             </ul>
 */
 private void writeObject(ObjectOutputStream out)
 throws IOException {
+final JMXNamespaceContext ctxt =
+JMXNamespaceContext.getSerializationContext();
 if (compat)
 {
 // Serializes this instance in the old serial form
 // Read CR 6441274 before making any changes to this code
 ObjectOutputStream.PutField fields = out.putFields();
-fields.put("domain", _canonicalName.substring(0, _domain_length));
+final String domain =
+changeContext(ctxt,_canonicalName.substring(0, _domain_length));
+final String cn =
+changeContext(ctxt,_canonicalName);
+fields.put("domain", domain);
 fields.put("propertyList", getKeyPropertyList());
 fields.put("propertyListString", getKeyPropertyListString());
-fields.put("canonicalName", _canonicalName);
+fields.put("canonicalName", cn);
 fields.put("pattern", (_domain_pattern || _property_list_pattern));
 fields.put("propertyPattern", _property_list_pattern);
 out.writeFields();
 }
 else
 {
 // Serializes this instance in the new serial form
 //
 out.defaultWriteObject();
-out.writeObject(getSerializedNameString());
+out.writeObject(changeContext(ctxt,getSerializedNameString()));
 }
 }
 //  Category : Serialization <===================================
 public static ObjectName getInstance(ObjectName name)
 throws NullPointerException {
 if (name.getClass().equals(ObjectName.class))
 return name;
 return Util.newObjectName(name.getSerializedNameString());
+}
+/**
+* Returns an {@code ObjectName} that is the same as this one but
+* with the specified domain.
+* This method preserves the original key order in the new instance.
+* If the provided name has a key property pattern, it will also be
+* preserved in the returned instance.
+*
+* @param newDomain The new domain for the returned instance;
+*        must not be null.
+* @return A new {@code ObjectName} that is the same as {@code this}
+*         except the domain is {@code newDomain}.
+* @throws NullPointerException if {@code newDomain} is null.
+* @throws MalformedObjectNameException if the new domain is syntactically
+*         illegal.
+* @since 1.7
+**/
+public final ObjectName withDomain(String newDomain)
+throws NullPointerException, MalformedObjectNameException {
+return new ObjectName(newDomain, this);
 }
 /**
 * Construct an object name from the given string.
 *
 throws NullPointerException, IllegalArgumentException {
 if (property == null)
 throw new NullPointerException("key property can't be null");
 for (int i = 0; i < _ca_array.length; i++) {
 Property prop = _ca_array[i];
-String key = prop.getKeyString(_canonicalName);
+String key = prop.getKeyString(_canonicalName,_domain_length);
 if (key.equals(property))
 return (prop instanceof PatternProperty);
 }
 throw new IllegalArgumentException("key property not found");
 }
 _propertyList = new HashMap<String,String>();
 int len = _ca_array.length;
 Property prop;
 for (int i = len - 1; i >= 0; i--) {
 prop = _ca_array[i];
-_propertyList.put(prop.getKeyString(_canonicalName),
+_propertyList.put(prop.getKeyString(_canonicalName,
-prop.getValueString(_canonicalName));
+_domain_length),
+prop.getValueString(_canonicalName,
+_domain_length));
 }
 }
 }
 return _propertyList;
 }
 dest_chars[end]   = ',';
 dest_chars[end+1] = '*';
 }
 }
-return new String(dest_chars);
+final String name = new String(dest_chars);
+return name;
 }
 /**
 * <p>Write a string representation of the list of key
 * properties specified at creation time in the given array, starting
 private int writeKeyPropertyListString(char[] canonicalChars,
 char[] data, int offset)  {
 if (_kp_array.length == 0) return offset;
 final char[] dest_chars = data;
-final char[] value = _canonicalName.toCharArray();
+final char[] value = canonicalChars;
 int index = offset;
 final int len = _kp_array.length;
 final int last = len - 1;
 for (int i = 0; i < len; i++) {
 final Property prop = _kp_array[i];
 final int prop_len = prop._key_length + prop._value_length + 1;
-System.arraycopy(value, prop._key_index, dest_chars, index,
+System.arraycopy(value, prop._key_index+_domain_length, dest_chars, index,
 prop_len);
 index += prop_len;
 if (i < last ) dest_chars[index++] = ',';
 }
 return index;
 // equality when canonical names are the same
 // (because usage of intern())
 ObjectName on = (ObjectName) object;
 String on_string = on._canonicalName;
-if (_canonicalName == on_string) return true;
+if (_canonicalName == on_string) return true;  // ES: OK
 // Because we are sharing canonical form between object names,
 // we have finished the comparison at this stage ==> unequal
 return false;
 }
 }
 private final boolean matchDomains(ObjectName name) {
 if (_domain_pattern) {
 // wildmatch domains
-final char[] dom_pattern = getDomain().toCharArray();
+// This ObjectName is the pattern
-final char[] dom_string  = name.getDomain().toCharArray();
+// The other ObjectName is the string.
-return wildmatch(dom_string,dom_pattern,0,0);
+return Util.wildpathmatch(name.getDomain(),getDomain());
 }
 return getDomain().equals(name.getDomain());
 }
 private final boolean matchKeys(ObjectName name) {
 for (int i = props.length - 1; i >= 0 ; i--) {
 // Find value in given object name for key at current
 // index in receiver
 //
 final Property p = props[i];
-final String   k = p.getKeyString(cn);
+final String   k = p.getKeyString(cn,_domain_length);
 final String   v = nameProps.get(k);
 // Did we find a value for this key ?
 //
 if (v == null) return false;
 // If this property is ok (same key, same value), go to next
 //
 if (_property_value_pattern && (p instanceof PatternProperty)) {
 // wildmatch key property values
-final char[] val_pattern =
+// p is the property pattern, v is the string
-p.getValueString(cn).toCharArray();
+if (Util.wildmatch(v,p.getValueString(cn,_domain_length)))
-final char[] val_string  = v.toCharArray();
-if (wildmatch(val_string,val_pattern,0,0))
 continue;
 else
 return false;
 }
-if (v.equals(p.getValueString(cn))) continue;
+if (v.equals(p.getValueString(cn,_domain_length))) continue;
 return false;
 }
 return true;
 }
 *         specified ObjectName.
 *
 * @since 1.6
 */
 public int compareTo(ObjectName name) {
+// Quick optimization:
+//
+if (name == this) return 0;
 // (1) Compare domains
 //
 int domainValue = this.getDomain().compareTo(name.getDomain());
 if (domainValue != 0)
 return domainValue;

changeset 1156	bbc2d15aaf7a
parent 1005	1a39b4e3f2fc
child 1225	6ef6227d36eb