home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / management / ObjectName.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  14.6 KB  |  1,011 lines
  1. package javax.management;
  2.  
  3. import com.sun.jmx.mbeanserver.GetPropertyAction;
  4. import java.io.IOException;
  5. import java.io.InvalidObjectException;
  6. import java.io.ObjectInputStream;
  7. import java.io.ObjectOutputStream;
  8. import java.io.ObjectStreamField;
  9. import java.security.AccessController;
  10. import java.util.Arrays;
  11. import java.util.Collections;
  12. import java.util.HashMap;
  13. import java.util.Hashtable;
  14. import java.util.Map;
  15.  
  16. public class ObjectName implements Comparable<ObjectName>, QueryExp {
  17.    private static final long oldSerialVersionUID = -5467795090068647408L;
  18.    private static final long newSerialVersionUID = 1081892073854801359L;
  19.    private static final ObjectStreamField[] oldSerialPersistentFields;
  20.    private static final ObjectStreamField[] newSerialPersistentFields;
  21.    private static final long serialVersionUID;
  22.    private static final ObjectStreamField[] serialPersistentFields;
  23.    private static boolean compat;
  24.    private static final Property[] _Empty_property_array;
  25.    private transient String _canonicalName;
  26.    private transient Property[] _kp_array;
  27.    private transient Property[] _ca_array;
  28.    private transient int _domain_length = 0;
  29.    private transient Map<String, String> _propertyList;
  30.    private transient boolean _domain_pattern = false;
  31.    private transient boolean _property_list_pattern = false;
  32.    private transient boolean _property_value_pattern = false;
  33.    public static final ObjectName WILDCARD;
  34.  
  35.    private void construct(String var1) throws MalformedObjectNameException, NullPointerException {
  36.       if (var1 == null) {
  37.          throw new NullPointerException("name cannot be null");
  38.       } else if (var1.length() == 0) {
  39.          this._canonicalName = "*:*";
  40.          this._kp_array = _Empty_property_array;
  41.          this._ca_array = _Empty_property_array;
  42.          this._domain_length = 1;
  43.          this._propertyList = null;
  44.          this._domain_pattern = true;
  45.          this._property_list_pattern = true;
  46.          this._property_value_pattern = false;
  47.       } else {
  48.          char[] var2 = var1.toCharArray();
  49.          int var3 = var2.length;
  50.          char[] var4 = new char[var3];
  51.          int var5 = 0;
  52.          int var6 = 0;
  53.  
  54.          label182:
  55.          while(true) {
  56.             if (var6 < var3) {
  57.                switch (var2[var6]) {
  58.                   case '\n':
  59.                      throw new MalformedObjectNameException("Invalid character '\\n' in domain name");
  60.                   case '*':
  61.                   case '?':
  62.                      this._domain_pattern = true;
  63.                      ++var6;
  64.                      continue;
  65.                   case ':':
  66.                      this._domain_length = var6++;
  67.                      break;
  68.                   case '=':
  69.                      ++var6;
  70.                      int var9 = var6;
  71.  
  72.                      do {
  73.                         if (var9 >= var3 || var2[var9++] == ':') {
  74.                            continue label182;
  75.                         }
  76.                      } while(var9 != var3);
  77.  
  78.                      throw new MalformedObjectNameException("Domain part must be specified");
  79.                   default:
  80.                      ++var6;
  81.                      continue;
  82.                }
  83.             }
  84.  
  85.             if (var6 == var3) {
  86.                throw new MalformedObjectNameException("Key properties cannot be empty");
  87.             }
  88.  
  89.             System.arraycopy(var2, 0, var4, 0, this._domain_length);
  90.             var4[this._domain_length] = ':';
  91.             var5 = this._domain_length + 1;
  92.             HashMap var10 = new HashMap();
  93.             int var14 = 0;
  94.             String[] var11 = new String[10];
  95.             this._kp_array = new Property[10];
  96.             this._property_list_pattern = false;
  97.             this._property_value_pattern = false;
  98.  
  99.             while(true) {
  100.                if (var6 < var3) {
  101.                   char var7 = var2[var6];
  102.                   if (var7 != '*') {
  103.                      int var15 = var6;
  104.                      if (var2[var6] == '=') {
  105.                         throw new MalformedObjectNameException("Invalid key (empty)");
  106.                      }
  107.  
  108.                      char var8;
  109.                      while(var15 < var3 && (var8 = var2[var15++]) != '=') {
  110.                         switch (var8) {
  111.                            case '\n':
  112.                            case '*':
  113.                            case ',':
  114.                            case ':':
  115.                            case '?':
  116.                               String var20 = var8 == '\n' ? "\\n" : "" + var8;
  117.                               throw new MalformedObjectNameException("Invalid character '" + var20 + "' in key part of property");
  118.                         }
  119.                      }
  120.  
  121.                      if (var2[var15 - 1] != '=') {
  122.                         throw new MalformedObjectNameException("Unterminated key property part");
  123.                      }
  124.  
  125.                      int var18 = var15;
  126.                      int var17 = var15 - var6 - 1;
  127.                      boolean var29 = false;
  128.                      boolean var13;
  129.                      int var19;
  130.                      if (var15 < var3 && var2[var15] == '"') {
  131.                         var13 = true;
  132.  
  133.                         while(true) {
  134.                            ++var15;
  135.                            if (var15 >= var3 || (var8 = var2[var15]) == '"') {
  136.                               if (var15 == var3) {
  137.                                  throw new MalformedObjectNameException("Unterminated quoted value");
  138.                               }
  139.  
  140.                               ++var15;
  141.                               var19 = var15 - var18;
  142.                               break;
  143.                            }
  144.  
  145.                            if (var8 == '\\') {
  146.                               ++var15;
  147.                               if (var15 == var3) {
  148.                                  throw new MalformedObjectNameException("Unterminated quoted value");
  149.                               }
  150.  
  151.                               switch (var8 = var2[var15]) {
  152.                                  case '"':
  153.                                  case '*':
  154.                                  case '?':
  155.                                  case '\\':
  156.                                  case 'n':
  157.                                     break;
  158.                                  default:
  159.                                     throw new MalformedObjectNameException("Invalid escape sequence '\\" + var8 + "' in quoted value");
  160.                               }
  161.                            } else {
  162.                               if (var8 == '\n') {
  163.                                  throw new MalformedObjectNameException("Newline in quoted value");
  164.                               }
  165.  
  166.                               switch (var8) {
  167.                                  case '*':
  168.                                  case '?':
  169.                                     var29 = true;
  170.                               }
  171.                            }
  172.                         }
  173.                      } else {
  174.                         var13 = false;
  175.  
  176.                         while(var15 < var3 && (var8 = var2[var15]) != ',') {
  177.                            switch (var8) {
  178.                               case '\n':
  179.                               case '"':
  180.                               case ':':
  181.                               case '=':
  182.                                  if (var8 == '\n') {
  183.                                     String var10000 = "\\n";
  184.                                  } else {
  185.                                     (new StringBuilder()).append("").append(var8).toString();
  186.                                  }
  187.  
  188.                                  throw new MalformedObjectNameException("Invalid character '" + var8 + "' in value part of property");
  189.                               case '*':
  190.                               case '?':
  191.                                  var29 = true;
  192.                                  ++var15;
  193.                                  break;
  194.                               default:
  195.                                  ++var15;
  196.                            }
  197.                         }
  198.  
  199.                         var19 = var15 - var18;
  200.                      }
  201.  
  202.                      if (var15 == var3 - 1) {
  203.                         if (var13) {
  204.                            throw new MalformedObjectNameException("Invalid ending character `" + var2[var15] + "'");
  205.                         }
  206.  
  207.                         throw new MalformedObjectNameException("Invalid ending comma");
  208.                      }
  209.  
  210.                      ++var15;
  211.                      Object var27;
  212.                      if (!var29) {
  213.                         var27 = new Property(var6, var17, var19);
  214.                      } else {
  215.                         this._property_value_pattern = true;
  216.                         var27 = new PatternProperty(var6, var17, var19);
  217.                      }
  218.  
  219.                      String var12 = var1.substring(var6, var6 + var17);
  220.                      if (var14 == var11.length) {
  221.                         String[] var21 = new String[var14 + 10];
  222.                         System.arraycopy(var11, 0, var21, 0, var14);
  223.                         var11 = var21;
  224.                      }
  225.  
  226.                      var11[var14] = var12;
  227.                      this.addProperty((Property)var27, var14, var10, var12);
  228.                      ++var14;
  229.                      var6 = var15;
  230.                      continue;
  231.                   }
  232.  
  233.                   if (this._property_list_pattern) {
  234.                      throw new MalformedObjectNameException("Cannot have several '*' characters in pattern property list");
  235.                   }
  236.  
  237.                   this._property_list_pattern = true;
  238.                   ++var6;
  239.                   if (var6 < var3 && var2[var6] != ',') {
  240.                      throw new MalformedObjectNameException("Invalid character found after '*': end of name or ',' expected");
  241.                   }
  242.  
  243.                   if (var6 != var3) {
  244.                      ++var6;
  245.                      continue;
  246.                   }
  247.  
  248.                   if (var14 == 0) {
  249.                      this._kp_array = _Empty_property_array;
  250.                      this._ca_array = _Empty_property_array;
  251.                      this._propertyList = Collections.emptyMap();
  252.                   }
  253.                }
  254.  
  255.                this.setCanonicalName(var2, var4, var11, var10, var5, var14);
  256.                return;
  257.             }
  258.          }
  259.       }
  260.    }
  261.  
  262.    private void construct(String var1, Map<String, String> var2) throws MalformedObjectNameException, NullPointerException {
  263.       if (var1 == null) {
  264.          throw new NullPointerException("domain cannot be null");
  265.       } else if (var2 == null) {
  266.          throw new NullPointerException("key property list cannot be null");
  267.       } else if (var2.isEmpty()) {
  268.          throw new MalformedObjectNameException("key property list cannot be empty");
  269.       } else if (!this.isDomain(var1)) {
  270.          throw new MalformedObjectNameException("Invalid domain: " + var1);
  271.       } else {
  272.          StringBuilder var3 = new StringBuilder();
  273.          var3.append(var1).append(':');
  274.          this._domain_length = var1.length();
  275.          int var4 = var2.size();
  276.          this._kp_array = new Property[var4];
  277.          String[] var5 = new String[var4];
  278.          HashMap var6 = new HashMap();
  279.          int var9 = 0;
  280.  
  281.          for(Map.Entry var11 : var2.entrySet()) {
  282.             if (var3.length() > 0) {
  283.                var3.append(",");
  284.             }
  285.  
  286.             String var12 = (String)var11.getKey();
  287.  
  288.             String var13;
  289.             try {
  290.                var13 = (String)var11.getValue();
  291.             } catch (ClassCastException var15) {
  292.                throw new MalformedObjectNameException(var15.getMessage());
  293.             }
  294.  
  295.             int var8 = var3.length();
  296.             checkKey(var12);
  297.             var3.append(var12);
  298.             var5[var9] = var12;
  299.             var3.append("=");
  300.             boolean var14 = checkValue(var13);
  301.             var3.append(var13);
  302.             Object var7;
  303.             if (!var14) {
  304.                var7 = new Property(var8, var12.length(), var13.length());
  305.             } else {
  306.                this._property_value_pattern = true;
  307.                var7 = new PatternProperty(var8, var12.length(), var13.length());
  308.             }
  309.  
  310.             this.addProperty((Property)var7, var9, var6, var12);
  311.             ++var9;
  312.          }
  313.  
  314.          int var16 = var3.length();
  315.          char[] var17 = new char[var16];
  316.          var3.getChars(0, var16, var17, 0);
  317.          char[] var18 = new char[var16];
  318.          System.arraycopy(var17, 0, var18, 0, this._domain_length + 1);
  319.          this.setCanonicalName(var17, var18, var5, var6, this._domain_length + 1, this._kp_array.length);
  320.       }
  321.    }
  322.  
  323.    private void addProperty(Property var1, int var2, Map<String, Property> var3, String var4) throws MalformedObjectNameException {
  324.       if (var3.containsKey(var4)) {
  325.          throw new MalformedObjectNameException("key `" + var4 + "' already defined");
  326.       } else {
  327.          if (var2 == this._kp_array.length) {
  328.             Property[] var5 = new Property[var2 + 10];
  329.             System.arraycopy(this._kp_array, 0, var5, 0, var2);
  330.             this._kp_array = var5;
  331.          }
  332.  
  333.          this._kp_array[var2] = var1;
  334.          var3.put(var4, var1);
  335.       }
  336.    }
  337.  
  338.    private void setCanonicalName(char[] var1, char[] var2, String[] var3, Map<String, Property> var4, int var5, int var6) {
  339.       if (this._kp_array != _Empty_property_array) {
  340.          String[] var7 = new String[var6];
  341.          Property[] var8 = new Property[var6];
  342.          System.arraycopy(var3, 0, var7, 0, var6);
  343.          Arrays.sort(var7);
  344.          var3 = var7;
  345.          System.arraycopy(this._kp_array, 0, var8, 0, var6);
  346.          this._kp_array = var8;
  347.          this._ca_array = new Property[var6];
  348.  
  349.          for(int var9 = 0; var9 < var6; ++var9) {
  350.             this._ca_array[var9] = (Property)var4.get(var3[var9]);
  351.          }
  352.  
  353.          int var14 = var6 - 1;
  354.  
  355.          for(int var12 = 0; var12 <= var14; ++var12) {
  356.             Property var11 = this._ca_array[var12];
  357.             int var10 = var11._key_length + var11._value_length + 1;
  358.             System.arraycopy(var1, var11._key_index, var2, var5, var10);
  359.             var11.setKeyIndex(var5);
  360.             var5 += var10;
  361.             if (var12 != var14) {
  362.                var2[var5] = ',';
  363.                ++var5;
  364.             }
  365.          }
  366.       }
  367.  
  368.       if (this._property_list_pattern) {
  369.          if (this._kp_array != _Empty_property_array) {
  370.             var2[var5++] = ',';
  371.          }
  372.  
  373.          var2[var5++] = '*';
  374.       }
  375.  
  376.       this._canonicalName = (new String(var2, 0, var5)).intern();
  377.    }
  378.  
  379.    private static int parseKey(char[] var0, int var1) throws MalformedObjectNameException {
  380.       int var2 = var1;
  381.       int var3 = var1;
  382.       int var4 = var0.length;
  383.  
  384.       while(true) {
  385.          if (var2 < var4) {
  386.             char var5 = var0[var2++];
  387.             switch (var5) {
  388.                case '\n':
  389.                case '*':
  390.                case ',':
  391.                case ':':
  392.                case '?':
  393.                   String var6 = var5 == '\n' ? "\\n" : "" + var5;
  394.                   throw new MalformedObjectNameException("Invalid character in key: `" + var6 + "'");
  395.                case '=':
  396.                   var3 = var2 - 1;
  397.                   break;
  398.                default:
  399.                   if (var2 < var4) {
  400.                      continue;
  401.                   }
  402.  
  403.                   var3 = var2;
  404.             }
  405.          }
  406.  
  407.          return var3;
  408.       }
  409.    }
  410.  
  411.    private static int[] parseValue(char[] var0, int var1) throws MalformedObjectNameException {
  412.       boolean var2 = false;
  413.       int var3 = var1;
  414.       int var4 = var1;
  415.       int var5 = var0.length;
  416.       char var6 = var0[var1];
  417.       if (var6 == '"') {
  418.          var3 = var1 + 1;
  419.          if (var3 == var5) {
  420.             throw new MalformedObjectNameException("Invalid quote");
  421.          }
  422.  
  423.          while(var3 < var5) {
  424.             char var11 = var0[var3];
  425.             if (var11 == '\\') {
  426.                ++var3;
  427.                if (var3 == var5) {
  428.                   throw new MalformedObjectNameException("Invalid unterminated quoted character sequence");
  429.                }
  430.  
  431.                var11 = var0[var3];
  432.                switch (var11) {
  433.                   case '"':
  434.                      if (var3 + 1 == var5) {
  435.                         throw new MalformedObjectNameException("Missing termination quote");
  436.                      }
  437.                   case '*':
  438.                   case '?':
  439.                   case '\\':
  440.                   case 'n':
  441.                      break;
  442.                   default:
  443.                      throw new MalformedObjectNameException("Invalid quoted character sequence '\\" + var11 + "'");
  444.                }
  445.             } else {
  446.                if (var11 == '\n') {
  447.                   throw new MalformedObjectNameException("Newline in quoted value");
  448.                }
  449.  
  450.                if (var11 == '"') {
  451.                   ++var3;
  452.                   break;
  453.                }
  454.  
  455.                switch (var11) {
  456.                   case '*':
  457.                   case '?':
  458.                      var2 = true;
  459.                }
  460.             }
  461.  
  462.             ++var3;
  463.             if (var3 >= var5 && var11 != '"') {
  464.                throw new MalformedObjectNameException("Missing termination quote");
  465.             }
  466.          }
  467.  
  468.          var4 = var3;
  469.          if (var3 < var5 && var0[var3++] != ',') {
  470.             throw new MalformedObjectNameException("Invalid quote");
  471.          }
  472.       } else {
  473.          while(var3 < var5) {
  474.             char var7 = var0[var3++];
  475.             switch (var7) {
  476.                case '\n':
  477.                case ':':
  478.                case '=':
  479.                   String var8 = var7 == '\n' ? "\\n" : "" + var7;
  480.                   throw new MalformedObjectNameException("Invalid character `" + var8 + "' in value");
  481.                case '*':
  482.                case '?':
  483.                   var2 = true;
  484.                   if (var3 >= var5) {
  485.                      var4 = var3;
  486.                      return new int[]{var4, var2 ? 1 : 0};
  487.                   }
  488.                   break;
  489.                case ',':
  490.                   var4 = var3 - 1;
  491.                   return new int[]{var4, var2 ? 1 : 0};
  492.                default:
  493.                   if (var3 >= var5) {
  494.                      var4 = var3;
  495.                      return new int[]{var4, var2 ? 1 : 0};
  496.                   }
  497.             }
  498.          }
  499.       }
  500.  
  501.       return new int[]{var4, var2 ? 1 : 0};
  502.    }
  503.  
  504.    private static boolean checkValue(String var0) throws MalformedObjectNameException {
  505.       if (var0 == null) {
  506.          throw new NullPointerException("Invalid value (null)");
  507.       } else {
  508.          int var1 = var0.length();
  509.          if (var1 == 0) {
  510.             return false;
  511.          } else {
  512.             char[] var2 = var0.toCharArray();
  513.             int[] var3 = parseValue(var2, 0);
  514.             int var4 = var3[0];
  515.             boolean var5 = var3[1] == 1;
  516.             if (var4 < var1) {
  517.                throw new MalformedObjectNameException("Invalid character in value: `" + var2[var4] + "'");
  518.             } else {
  519.                return var5;
  520.             }
  521.          }
  522.       }
  523.    }
  524.  
  525.    private static void checkKey(String var0) throws MalformedObjectNameException, NullPointerException {
  526.       if (var0 == null) {
  527.          throw new NullPointerException("Invalid key (null)");
  528.       } else {
  529.          int var1 = var0.length();
  530.          if (var1 == 0) {
  531.             throw new MalformedObjectNameException("Invalid key (empty)");
  532.          } else {
  533.             char[] var2 = var0.toCharArray();
  534.             int var3 = parseKey(var2, 0);
  535.             if (var3 < var1) {
  536.                throw new MalformedObjectNameException("Invalid character in value: `" + var2[var3] + "'");
  537.             }
  538.          }
  539.       }
  540.    }
  541.  
  542.    private static boolean wildmatch(char[] var0, char[] var1, int var2, int var3) {
  543.       int var5 = var0.length;
  544.       int var6 = var1.length;
  545.  
  546.       while(var3 < var6) {
  547.          char var4 = var1[var3++];
  548.          if (var4 != '?') {
  549.             if (var4 == '*') {
  550.                if (var3 >= var6) {
  551.                   return true;
  552.                }
  553.  
  554.                while(!wildmatch(var0, var1, var2, var3)) {
  555.                   ++var2;
  556.                   if (var2 >= var5) {
  557.                      return false;
  558.                   }
  559.                }
  560.  
  561.                return true;
  562.             }
  563.  
  564.             if (var2 >= var5 || var4 != var0[var2++]) {
  565.                return false;
  566.             }
  567.          } else {
  568.             ++var2;
  569.             if (var2 > var5) {
  570.                return false;
  571.             }
  572.          }
  573.       }
  574.  
  575.       return var2 == var5;
  576.    }
  577.  
  578.    private boolean isDomain(String var1) {
  579.       if (var1 == null) {
  580.          return true;
  581.       } else {
  582.          char[] var2 = var1.toCharArray();
  583.          int var3 = var2.length;
  584.          int var4 = 0;
  585.  
  586.          while(var4 < var3) {
  587.             char var5 = var2[var4++];
  588.             switch (var5) {
  589.                case '\n':
  590.                case ':':
  591.                   return false;
  592.                case '*':
  593.                case '?':
  594.                   this._domain_pattern = true;
  595.             }
  596.          }
  597.  
  598.          return true;
  599.       }
  600.    }
  601.  
  602.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  603.       String var2;
  604.       if (compat) {
  605.          ObjectInputStream.GetField var3 = var1.readFields();
  606.          var2 = (String)var3.get("domain", "default") + ":" + (String)var3.get("propertyListString", "");
  607.       } else {
  608.          var1.defaultReadObject();
  609.          var2 = (String)var1.readObject();
  610.       }
  611.  
  612.       try {
  613.          this.construct(var2);
  614.       } catch (NullPointerException var4) {
  615.          throw new InvalidObjectException(var4.toString());
  616.       } catch (MalformedObjectNameException var5) {
  617.          throw new InvalidObjectException(var5.toString());
  618.       }
  619.    }
  620.  
  621.    private void writeObject(ObjectOutputStream var1) throws IOException {
  622.       if (compat) {
  623.          ObjectOutputStream.PutField var2 = var1.putFields();
  624.          var2.put("domain", this._canonicalName.substring(0, this._domain_length));
  625.          var2.put("propertyList", this.getKeyPropertyList());
  626.          var2.put("propertyListString", this.getKeyPropertyListString());
  627.          var2.put("canonicalName", this._canonicalName);
  628.          var2.put("pattern", this._domain_pattern || this._property_list_pattern);
  629.          var2.put("propertyPattern", this._property_list_pattern);
  630.          var1.writeFields();
  631.       } else {
  632.          var1.defaultWriteObject();
  633.          var1.writeObject(this.getSerializedNameString());
  634.       }
  635.  
  636.    }
  637.  
  638.    public static ObjectName getInstance(String var0) throws MalformedObjectNameException, NullPointerException {
  639.       return new ObjectName(var0);
  640.    }
  641.  
  642.    public static ObjectName getInstance(String var0, String var1, String var2) throws MalformedObjectNameException, NullPointerException {
  643.       return new ObjectName(var0, var1, var2);
  644.    }
  645.  
  646.    public static ObjectName getInstance(String var0, Hashtable<String, String> var1) throws MalformedObjectNameException, NullPointerException {
  647.       return new ObjectName(var0, var1);
  648.    }
  649.  
  650.    public static ObjectName getInstance(ObjectName var0) throws NullPointerException {
  651.       if (var0.getClass().equals(ObjectName.class)) {
  652.          return var0;
  653.       } else {
  654.          try {
  655.             return new ObjectName(var0.getSerializedNameString());
  656.          } catch (MalformedObjectNameException var2) {
  657.             throw new IllegalArgumentException("Unexpected: " + var2);
  658.          }
  659.       }
  660.    }
  661.  
  662.    public ObjectName(String var1) throws MalformedObjectNameException, NullPointerException {
  663.       this.construct(var1);
  664.    }
  665.  
  666.    public ObjectName(String var1, String var2, String var3) throws MalformedObjectNameException, NullPointerException {
  667.       Map var4 = Collections.singletonMap(var2, var3);
  668.       this.construct(var1, var4);
  669.    }
  670.  
  671.    public ObjectName(String var1, Hashtable<String, String> var2) throws MalformedObjectNameException, NullPointerException {
  672.       this.construct(var1, var2);
  673.    }
  674.  
  675.    public boolean isPattern() {
  676.       return this._domain_pattern || this._property_list_pattern || this._property_value_pattern;
  677.    }
  678.  
  679.    public boolean isDomainPattern() {
  680.       return this._domain_pattern;
  681.    }
  682.  
  683.    public boolean isPropertyPattern() {
  684.       return this._property_list_pattern || this._property_value_pattern;
  685.    }
  686.  
  687.    public boolean isPropertyListPattern() {
  688.       return this._property_list_pattern;
  689.    }
  690.  
  691.    public boolean isPropertyValuePattern() {
  692.       return this._property_value_pattern;
  693.    }
  694.  
  695.    public boolean isPropertyValuePattern(String var1) throws NullPointerException, IllegalArgumentException {
  696.       if (var1 == null) {
  697.          throw new NullPointerException("key property can't be null");
  698.       } else {
  699.          for(int var2 = 0; var2 < this._ca_array.length; ++var2) {
  700.             Property var3 = this._ca_array[var2];
  701.             String var4 = var3.getKeyString(this._canonicalName);
  702.             if (var4.equals(var1)) {
  703.                return var3 instanceof PatternProperty;
  704.             }
  705.          }
  706.  
  707.          throw new IllegalArgumentException("key property not found");
  708.       }
  709.    }
  710.  
  711.    public String getCanonicalName() {
  712.       return this._canonicalName;
  713.    }
  714.  
  715.    public String getDomain() {
  716.       return this._canonicalName.substring(0, this._domain_length);
  717.    }
  718.  
  719.    public String getKeyProperty(String var1) throws NullPointerException {
  720.       return (String)this._getKeyPropertyList().get(var1);
  721.    }
  722.  
  723.    private Map<String, String> _getKeyPropertyList() {
  724.       synchronized(this) {
  725.          if (this._propertyList == null) {
  726.             this._propertyList = new HashMap();
  727.             int var2 = this._ca_array.length;
  728.  
  729.             for(int var4 = var2 - 1; var4 >= 0; --var4) {
  730.                Property var3 = this._ca_array[var4];
  731.                this._propertyList.put(var3.getKeyString(this._canonicalName), var3.getValueString(this._canonicalName));
  732.             }
  733.          }
  734.       }
  735.  
  736.       return this._propertyList;
  737.    }
  738.  
  739.    public Hashtable<String, String> getKeyPropertyList() {
  740.       return new Hashtable(this._getKeyPropertyList());
  741.    }
  742.  
  743.    public String getKeyPropertyListString() {
  744.       if (this._kp_array.length == 0) {
  745.          return "";
  746.       } else {
  747.          int var1 = this._canonicalName.length() - this._domain_length - 1 - (this._property_list_pattern ? 2 : 0);
  748.          char[] var2 = new char[var1];
  749.          char[] var3 = this._canonicalName.toCharArray();
  750.          this.writeKeyPropertyListString(var3, var2, 0);
  751.          return new String(var2);
  752.       }
  753.    }
  754.  
  755.    private String getSerializedNameString() {
  756.       int var1 = this._canonicalName.length();
  757.       char[] var2 = new char[var1];
  758.       char[] var3 = this._canonicalName.toCharArray();
  759.       int var4 = this._domain_length + 1;
  760.       System.arraycopy(var3, 0, var2, 0, var4);
  761.       int var5 = this.writeKeyPropertyListString(var3, var2, var4);
  762.       if (this._property_list_pattern) {
  763.          if (var5 == var4) {
  764.             var2[var5] = '*';
  765.          } else {
  766.             var2[var5] = ',';
  767.             var2[var5 + 1] = '*';
  768.          }
  769.       }
  770.  
  771.       return new String(var2);
  772.    }
  773.  
  774.    private int writeKeyPropertyListString(char[] var1, char[] var2, int var3) {
  775.       if (this._kp_array.length == 0) {
  776.          return var3;
  777.       } else {
  778.          char[] var4 = var2;
  779.          char[] var5 = this._canonicalName.toCharArray();
  780.          int var6 = var3;
  781.          int var7 = this._kp_array.length;
  782.          int var8 = var7 - 1;
  783.  
  784.          for(int var9 = 0; var9 < var7; ++var9) {
  785.             Property var10 = this._kp_array[var9];
  786.             int var11 = var10._key_length + var10._value_length + 1;
  787.             System.arraycopy(var5, var10._key_index, var4, var6, var11);
  788.             var6 += var11;
  789.             if (var9 < var8) {
  790.                var4[var6++] = ',';
  791.             }
  792.          }
  793.  
  794.          return var6;
  795.       }
  796.    }
  797.  
  798.    public String getCanonicalKeyPropertyListString() {
  799.       if (this._ca_array.length == 0) {
  800.          return "";
  801.       } else {
  802.          int var1 = this._canonicalName.length();
  803.          if (this._property_list_pattern) {
  804.             var1 -= 2;
  805.          }
  806.  
  807.          return this._canonicalName.substring(this._domain_length + 1, var1);
  808.       }
  809.    }
  810.  
  811.    public String toString() {
  812.       return this.getSerializedNameString();
  813.    }
  814.  
  815.    public boolean equals(Object var1) {
  816.       if (this == var1) {
  817.          return true;
  818.       } else if (!(var1 instanceof ObjectName)) {
  819.          return false;
  820.       } else {
  821.          ObjectName var2 = (ObjectName)var1;
  822.          String var3 = var2._canonicalName;
  823.          return this._canonicalName == var3;
  824.       }
  825.    }
  826.  
  827.    public int hashCode() {
  828.       return this._canonicalName.hashCode();
  829.    }
  830.  
  831.    public static String quote(String var0) throws NullPointerException {
  832.       StringBuilder var1 = new StringBuilder("\"");
  833.       int var2 = var0.length();
  834.  
  835.       for(int var3 = 0; var3 < var2; ++var3) {
  836.          char var4 = var0.charAt(var3);
  837.          switch (var4) {
  838.             case '\n':
  839.                var4 = 'n';
  840.                var1.append('\\');
  841.                break;
  842.             case '"':
  843.             case '*':
  844.             case '?':
  845.             case '\\':
  846.                var1.append('\\');
  847.          }
  848.  
  849.          var1.append(var4);
  850.       }
  851.  
  852.       var1.append('"');
  853.       return var1.toString();
  854.    }
  855.  
  856.    public static String unquote(String var0) throws IllegalArgumentException, NullPointerException {
  857.       StringBuilder var1 = new StringBuilder();
  858.       int var2 = var0.length();
  859.       if (var2 >= 2 && var0.charAt(0) == '"' && var0.charAt(var2 - 1) == '"') {
  860.          for(int var3 = 1; var3 < var2 - 1; ++var3) {
  861.             char var4 = var0.charAt(var3);
  862.             if (var4 == '\\') {
  863.                if (var3 == var2 - 2) {
  864.                   throw new IllegalArgumentException("Trailing backslash");
  865.                }
  866.  
  867.                ++var3;
  868.                var4 = var0.charAt(var3);
  869.                switch (var4) {
  870.                   case '"':
  871.                   case '*':
  872.                   case '?':
  873.                   case '\\':
  874.                      break;
  875.                   case 'n':
  876.                      var4 = '\n';
  877.                      break;
  878.                   default:
  879.                      throw new IllegalArgumentException("Bad character '" + var4 + "' after backslash");
  880.                }
  881.             } else {
  882.                switch (var4) {
  883.                   case '\n':
  884.                   case '"':
  885.                   case '*':
  886.                   case '?':
  887.                      throw new IllegalArgumentException("Invalid unescaped character '" + var4 + "' in the string to unquote");
  888.                }
  889.             }
  890.  
  891.             var1.append(var4);
  892.          }
  893.  
  894.          return var1.toString();
  895.       } else {
  896.          throw new IllegalArgumentException("Argument not quoted");
  897.       }
  898.    }
  899.  
  900.    public boolean apply(ObjectName var1) throws NullPointerException {
  901.       if (var1 == null) {
  902.          throw new NullPointerException();
  903.       } else if (!var1._domain_pattern && !var1._property_list_pattern && !var1._property_value_pattern) {
  904.          if (!this._domain_pattern && !this._property_list_pattern && !this._property_value_pattern) {
  905.             return this._canonicalName.equals(var1._canonicalName);
  906.          } else {
  907.             return this.matchDomains(var1) && this.matchKeys(var1);
  908.          }
  909.       } else {
  910.          return false;
  911.       }
  912.    }
  913.  
  914.    private final boolean matchDomains(ObjectName var1) {
  915.       if (this._domain_pattern) {
  916.          char[] var2 = this.getDomain().toCharArray();
  917.          char[] var3 = var1.getDomain().toCharArray();
  918.          return wildmatch(var3, var2, 0, 0);
  919.       } else {
  920.          return this.getDomain().equals(var1.getDomain());
  921.       }
  922.    }
  923.  
  924.    private final boolean matchKeys(ObjectName var1) {
  925.       if (this._property_value_pattern && !this._property_list_pattern && var1._ca_array.length != this._ca_array.length) {
  926.          return false;
  927.       } else if (!this._property_value_pattern && !this._property_list_pattern) {
  928.          String var11 = var1.getCanonicalKeyPropertyListString();
  929.          String var12 = this.getCanonicalKeyPropertyListString();
  930.          return var11.equals(var12);
  931.       } else {
  932.          Map var2 = var1._getKeyPropertyList();
  933.          Property[] var3 = this._ca_array;
  934.          String var4 = this._canonicalName;
  935.  
  936.          for(int var5 = var3.length - 1; var5 >= 0; --var5) {
  937.             Property var6 = var3[var5];
  938.             String var7 = var6.getKeyString(var4);
  939.             String var8 = (String)var2.get(var7);
  940.             if (var8 == null) {
  941.                return false;
  942.             }
  943.  
  944.             if (this._property_value_pattern && var6 instanceof PatternProperty) {
  945.                char[] var9 = var6.getValueString(var4).toCharArray();
  946.                char[] var10 = var8.toCharArray();
  947.                if (!wildmatch(var10, var9, 0, 0)) {
  948.                   return false;
  949.                }
  950.             } else if (!var8.equals(var6.getValueString(var4))) {
  951.                return false;
  952.             }
  953.          }
  954.  
  955.          return true;
  956.       }
  957.    }
  958.  
  959.    public void setMBeanServer(MBeanServer var1) {
  960.    }
  961.  
  962.    public int compareTo(ObjectName var1) {
  963.       int var2 = this.getDomain().compareTo(var1.getDomain());
  964.       if (var2 != 0) {
  965.          return var2;
  966.       } else {
  967.          String var3 = this.getKeyProperty("type");
  968.          String var4 = var1.getKeyProperty("type");
  969.          if (var3 == null) {
  970.             var3 = "";
  971.          }
  972.  
  973.          if (var4 == null) {
  974.             var4 = "";
  975.          }
  976.  
  977.          int var5 = var3.compareTo(var4);
  978.          return var5 != 0 ? var5 : this.getCanonicalName().compareTo(var1.getCanonicalName());
  979.       }
  980.    }
  981.  
  982.    static {
  983.       oldSerialPersistentFields = new ObjectStreamField[]{new ObjectStreamField("domain", String.class), new ObjectStreamField("propertyList", Hashtable.class), new ObjectStreamField("propertyListString", String.class), new ObjectStreamField("canonicalName", String.class), new ObjectStreamField("pattern", Boolean.TYPE), new ObjectStreamField("propertyPattern", Boolean.TYPE)};
  984.       newSerialPersistentFields = new ObjectStreamField[0];
  985.       compat = false;
  986.  
  987.       try {
  988.          GetPropertyAction var0 = new GetPropertyAction("jmx.serial.form");
  989.          String var1 = (String)AccessController.doPrivileged(var0);
  990.          compat = var1 != null && var1.equals("1.0");
  991.       } catch (Exception var3) {
  992.       }
  993.  
  994.       if (compat) {
  995.          serialPersistentFields = oldSerialPersistentFields;
  996.          serialVersionUID = -5467795090068647408L;
  997.       } else {
  998.          serialPersistentFields = newSerialPersistentFields;
  999.          serialVersionUID = 1081892073854801359L;
  1000.       }
  1001.  
  1002.       _Empty_property_array = new Property[0];
  1003.  
  1004.       try {
  1005.          WILDCARD = new ObjectName("*:*");
  1006.       } catch (MalformedObjectNameException var2) {
  1007.          throw new Error("Can't initialize wildcard name", var2);
  1008.       }
  1009.    }
  1010. }
  1011.