home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / Share / Java / JDesignerPro / Jdp3_0.exe / data1.cab / Program_Files / javax / naming / NameImpl.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-09  |  9.7 KB  |  568 lines
  1. package javax.naming;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Enumeration;
  5. import java.util.NoSuchElementException;
  6. import java.util.Properties;
  7. import java.util.Vector;
  8.  
  9. class NameImpl implements Serializable {
  10.    private Vector components;
  11.    private String syntaxDirection;
  12.    private String syntaxSeparator;
  13.    private String syntaxSeparator2;
  14.    private boolean syntaxCaseInsensitive;
  15.    private boolean syntaxTrimBlanks;
  16.    private String syntaxEscape;
  17.    private String syntaxBeginQuote1;
  18.    private String syntaxEndQuote1;
  19.    private String syntaxBeginQuote2;
  20.    private String syntaxEndQuote2;
  21.    private String syntaxAvaSeparator;
  22.    private String syntaxTypevalSeparator;
  23.    private final int STYLE_NONE;
  24.    private final int STYLE_QUOTE1;
  25.    private final int STYLE_QUOTE2;
  26.    private final int STYLE_ESCAPE;
  27.    private int escapingStyle;
  28.  
  29.    private final boolean isA(String var1, int var2, String var3) {
  30.       return var3 != null && var1.startsWith(var3, var2);
  31.    }
  32.  
  33.    private final boolean isMeta(String var1, int var2) {
  34.       return this.isA(var1, var2, this.syntaxEscape) || this.isA(var1, var2, this.syntaxBeginQuote1) || this.isA(var1, var2, this.syntaxBeginQuote2) || this.isSeparator(var1, var2);
  35.    }
  36.  
  37.    private final boolean isSeparator(String var1, int var2) {
  38.       return this.isA(var1, var2, this.syntaxSeparator) || this.isA(var1, var2, this.syntaxSeparator2);
  39.    }
  40.  
  41.    private final int skipSeparator(String var1, int var2) {
  42.       if (this.isA(var1, var2, this.syntaxSeparator)) {
  43.          var2 += this.syntaxSeparator.length();
  44.       } else if (this.isA(var1, var2, this.syntaxSeparator2)) {
  45.          var2 += this.syntaxSeparator2.length();
  46.       }
  47.  
  48.       return var2;
  49.    }
  50.  
  51.    private final int extractComp(String var1, int var2, int var3, Vector var4) throws InvalidNameException {
  52.       boolean var7 = true;
  53.       boolean var8 = false;
  54.  
  55.       StringBuffer var9;
  56.       for(var9 = new StringBuffer(var3); var2 < var3; var7 = false) {
  57.          if (var7 && ((var8 = this.isA(var1, var2, this.syntaxBeginQuote1)) || this.isA(var1, var2, this.syntaxBeginQuote2))) {
  58.             String var13 = var8 ? this.syntaxBeginQuote1 : this.syntaxBeginQuote2;
  59.             String var14 = var8 ? this.syntaxEndQuote1 : this.syntaxEndQuote2;
  60.             if (this.escapingStyle == 0) {
  61.                this.escapingStyle = var8 ? 1 : 2;
  62.             }
  63.  
  64.             for(var2 += var13.length(); var2 < var3 && !var1.startsWith(var14, var2); ++var2) {
  65.                if (this.isA(var1, var2, this.syntaxEscape) && this.isA(var1, var2 + this.syntaxEscape.length(), var14)) {
  66.                   var2 += this.syntaxEscape.length();
  67.                }
  68.  
  69.                var9.append(var1.charAt(var2));
  70.             }
  71.  
  72.             if (var2 >= var3) {
  73.                throw new InvalidNameException(var1 + ": no close quote");
  74.             }
  75.  
  76.             var2 += var14.length();
  77.             if (var2 != var3 && !this.isSeparator(var1, var2)) {
  78.                throw new InvalidNameException(var1 + ": close quote appears before end of component");
  79.             }
  80.             break;
  81.          }
  82.  
  83.          if (this.isSeparator(var1, var2)) {
  84.             break;
  85.          }
  86.  
  87.          if (this.isA(var1, var2, this.syntaxEscape)) {
  88.             if (this.isMeta(var1, var2 + this.syntaxEscape.length())) {
  89.                var2 += this.syntaxEscape.length();
  90.                if (this.escapingStyle == 0) {
  91.                   this.escapingStyle = 3;
  92.                }
  93.             } else if (var2 + this.syntaxEscape.length() >= var3) {
  94.                throw new InvalidNameException(var1 + ": unescaped " + this.syntaxEscape + " at end of component");
  95.             }
  96.          } else if (this.isA(var1, var2, this.syntaxTypevalSeparator) && ((var8 = this.isA(var1, var2 + this.syntaxTypevalSeparator.length(), this.syntaxBeginQuote1)) || this.isA(var1, var2 + this.syntaxTypevalSeparator.length(), this.syntaxBeginQuote2))) {
  97.             String var5 = var8 ? this.syntaxBeginQuote1 : this.syntaxBeginQuote2;
  98.             String var6 = var8 ? this.syntaxEndQuote1 : this.syntaxEndQuote2;
  99.             var2 += this.syntaxTypevalSeparator.length();
  100.             var9.append(this.syntaxTypevalSeparator + var5);
  101.  
  102.             for(var2 += var5.length(); var2 < var3 && !var1.startsWith(var6, var2); ++var2) {
  103.                if (this.isA(var1, var2, this.syntaxEscape) && this.isA(var1, var2 + this.syntaxEscape.length(), var6)) {
  104.                   var2 += this.syntaxEscape.length();
  105.                }
  106.  
  107.                var9.append(var1.charAt(var2));
  108.             }
  109.  
  110.             if (var2 >= var3) {
  111.                throw new InvalidNameException(var1 + ": typeval no close quote");
  112.             }
  113.  
  114.             var2 += var6.length();
  115.             var9.append(var6);
  116.             if (var2 != var3 && !this.isSeparator(var1, var2)) {
  117.                throw new InvalidNameException(var1.substring(var2) + ": typeval close quote appears before end of component");
  118.             }
  119.             break;
  120.          }
  121.  
  122.          var9.append(var1.charAt(var2++));
  123.       }
  124.  
  125.       if (this.syntaxDirection.equals("right_to_left")) {
  126.          var4.insertElementAt(var9.toString(), 0);
  127.       } else {
  128.          var4.addElement(var9.toString());
  129.       }
  130.  
  131.       return var2;
  132.    }
  133.  
  134.    private static boolean getBoolean(Properties var0, String var1) {
  135.       return toBoolean(var0.getProperty(var1));
  136.    }
  137.  
  138.    private static boolean toBoolean(String var0) {
  139.       return var0 != null && var0.toLowerCase().equals("true");
  140.    }
  141.  
  142.    private final void recordNamingConvention(Properties var1) {
  143.       this.syntaxDirection = var1.getProperty("jndi.syntax.direction", "flat");
  144.       if (!this.syntaxDirection.equals("left_to_right") && !this.syntaxDirection.equals("right_to_left") && !this.syntaxDirection.equals("flat")) {
  145.          throw new IllegalArgumentException(this.syntaxDirection + "is not a valid value for the jndi.syntax.direction property");
  146.       } else {
  147.          if (!this.syntaxDirection.equals("flat")) {
  148.             this.syntaxSeparator = var1.getProperty("jndi.syntax.separator");
  149.             this.syntaxSeparator2 = var1.getProperty("jndi.syntax.separator2");
  150.             if (this.syntaxSeparator == null) {
  151.                throw new IllegalArgumentException("jndi.syntax.separator property required for non-flat syntax");
  152.             }
  153.          }
  154.  
  155.          this.syntaxEscape = var1.getProperty("jndi.syntax.escape");
  156.          this.syntaxCaseInsensitive = getBoolean(var1, "jndi.syntax.ignorecase");
  157.          this.syntaxTrimBlanks = getBoolean(var1, "jndi.syntax.trimblanks");
  158.          this.syntaxBeginQuote1 = var1.getProperty("jndi.syntax.beginquote");
  159.          this.syntaxEndQuote1 = var1.getProperty("jndi.syntax.endquote");
  160.          if (this.syntaxEndQuote1 == null && this.syntaxBeginQuote1 != null) {
  161.             this.syntaxEndQuote1 = this.syntaxBeginQuote1;
  162.          } else if (this.syntaxBeginQuote1 == null && this.syntaxEndQuote1 != null) {
  163.             this.syntaxBeginQuote1 = this.syntaxEndQuote1;
  164.          }
  165.  
  166.          this.syntaxBeginQuote2 = var1.getProperty("jndi.syntax.beginquote2");
  167.          this.syntaxEndQuote2 = var1.getProperty("jndi.syntax.endquote2");
  168.          if (this.syntaxEndQuote2 == null && this.syntaxBeginQuote2 != null) {
  169.             this.syntaxEndQuote2 = this.syntaxBeginQuote2;
  170.          } else if (this.syntaxBeginQuote2 == null && this.syntaxEndQuote2 != null) {
  171.             this.syntaxBeginQuote2 = this.syntaxEndQuote2;
  172.          }
  173.  
  174.          this.syntaxAvaSeparator = var1.getProperty("jndi.syntax.separator.ava");
  175.          this.syntaxTypevalSeparator = var1.getProperty("jndi.syntax.separator.typeval");
  176.       }
  177.    }
  178.  
  179.    NameImpl(Properties var1) {
  180.       this.STYLE_QUOTE1 = 1;
  181.       this.STYLE_QUOTE2 = 2;
  182.       this.STYLE_ESCAPE = 3;
  183.       this.escapingStyle = 0;
  184.       this.recordNamingConvention(var1);
  185.       this.components = new Vector();
  186.    }
  187.  
  188.    NameImpl(Properties var1, String var2) throws InvalidNameException {
  189.       this(var1);
  190.       boolean var3 = this.syntaxDirection.equals("right_to_left");
  191.       boolean var4 = true;
  192.       int var5 = var2.length();
  193.       int var6 = 0;
  194.  
  195.       while(var6 < var5) {
  196.          var6 = this.extractComp(var2, var6, var5, this.components);
  197.          String var7 = var3 ? (String)this.components.firstElement() : (String)this.components.lastElement();
  198.          if (var7.length() >= 1) {
  199.             var4 = false;
  200.          }
  201.  
  202.          if (var6 < var5) {
  203.             var6 = this.skipSeparator(var2, var6);
  204.             if (var6 == var5 && !var4) {
  205.                if (var3) {
  206.                   this.components.insertElementAt("", 0);
  207.                } else {
  208.                   this.components.addElement("");
  209.                }
  210.             }
  211.          }
  212.       }
  213.  
  214.    }
  215.  
  216.    NameImpl(Properties var1, Enumeration var2) {
  217.       this(var1);
  218.  
  219.       while(var2.hasMoreElements()) {
  220.          this.components.addElement(var2.nextElement());
  221.       }
  222.  
  223.    }
  224.  
  225.    private final String stringifyComp(String var1) {
  226.       int var2 = var1.length();
  227.       boolean var3 = false;
  228.       boolean var4 = false;
  229.       String var5 = null;
  230.       String var6 = null;
  231.       StringBuffer var7 = new StringBuffer(var2);
  232.       if (this.syntaxSeparator != null && var1.indexOf(this.syntaxSeparator) >= 0) {
  233.          if (this.syntaxBeginQuote1 != null) {
  234.             var5 = this.syntaxBeginQuote1;
  235.             var6 = this.syntaxEndQuote1;
  236.          } else if (this.syntaxBeginQuote2 != null) {
  237.             var5 = this.syntaxBeginQuote2;
  238.             var6 = this.syntaxEndQuote2;
  239.          } else if (this.syntaxEscape != null) {
  240.             var3 = true;
  241.          }
  242.       }
  243.  
  244.       if (this.syntaxSeparator2 != null && var1.indexOf(this.syntaxSeparator2) >= 0) {
  245.          if (this.syntaxBeginQuote1 != null) {
  246.             if (var5 == null) {
  247.                var5 = this.syntaxBeginQuote1;
  248.                var6 = this.syntaxEndQuote1;
  249.             }
  250.          } else if (this.syntaxBeginQuote2 != null) {
  251.             if (var5 == null) {
  252.                var5 = this.syntaxBeginQuote2;
  253.                var6 = this.syntaxEndQuote2;
  254.             }
  255.          } else if (this.syntaxEscape != null) {
  256.             var4 = true;
  257.          }
  258.       }
  259.  
  260.       if (var5 != null) {
  261.          var7 = var7.append(var5);
  262.          int var8 = 0;
  263.  
  264.          while(var8 < var2) {
  265.             if (var1.startsWith(var6, var8)) {
  266.                var7.append(this.syntaxEscape).append(var6);
  267.                var8 += var6.length();
  268.             } else {
  269.                var7.append(var1.charAt(var8++));
  270.             }
  271.          }
  272.  
  273.          var7.append(var6);
  274.       } else {
  275.          boolean var10 = true;
  276.  
  277.          for(int var9 = 0; var9 < var2; var10 = false) {
  278.             if (var10 && this.isA(var1, var9, this.syntaxBeginQuote1)) {
  279.                var7.append(this.syntaxEscape).append(this.syntaxBeginQuote1);
  280.                var9 += this.syntaxBeginQuote1.length();
  281.             } else if (var10 && this.isA(var1, var9, this.syntaxBeginQuote2)) {
  282.                var7.append(this.syntaxEscape).append(this.syntaxBeginQuote2);
  283.                var9 += this.syntaxBeginQuote2.length();
  284.             } else if (this.isA(var1, var9, this.syntaxEscape)) {
  285.                if (var9 + this.syntaxEscape.length() >= var2) {
  286.                   var7.append(this.syntaxEscape);
  287.                } else if (this.isMeta(var1, var9 + this.syntaxEscape.length())) {
  288.                   var7.append(this.syntaxEscape);
  289.                }
  290.  
  291.                var7.append(this.syntaxEscape);
  292.                var9 += this.syntaxEscape.length();
  293.             } else if (var3 && var1.startsWith(this.syntaxSeparator, var9)) {
  294.                var7.append(this.syntaxEscape).append(this.syntaxSeparator);
  295.                var9 += this.syntaxSeparator.length();
  296.             } else if (var4 && var1.startsWith(this.syntaxSeparator2, var9)) {
  297.                var7.append(this.syntaxEscape).append(this.syntaxSeparator2);
  298.                var9 += this.syntaxSeparator2.length();
  299.             } else {
  300.                var7.append(var1.charAt(var9++));
  301.             }
  302.          }
  303.       }
  304.  
  305.       return var7.toString();
  306.    }
  307.  
  308.    public String toString() {
  309.       StringBuffer var1 = new StringBuffer();
  310.       boolean var3 = true;
  311.       int var4 = this.components.size();
  312.  
  313.       for(int var5 = 0; var5 < var4; ++var5) {
  314.          String var2;
  315.          if (this.syntaxDirection.equals("right_to_left")) {
  316.             var2 = this.stringifyComp((String)this.components.elementAt(var4 - 1 - var5));
  317.          } else {
  318.             var2 = this.stringifyComp((String)this.components.elementAt(var5));
  319.          }
  320.  
  321.          if (var5 != 0 && this.syntaxSeparator != null) {
  322.             var1.append(this.syntaxSeparator);
  323.          }
  324.  
  325.          if (var2.length() >= 1) {
  326.             var3 = false;
  327.          }
  328.  
  329.          var1 = var1.append(var2);
  330.       }
  331.  
  332.       if (var3 && var4 >= 1 && this.syntaxSeparator != null) {
  333.          var1 = var1.append(this.syntaxSeparator);
  334.       }
  335.  
  336.       return var1.toString();
  337.    }
  338.  
  339.    public boolean equals(Object var1) {
  340.       if (var1 != null && var1 instanceof NameImpl) {
  341.          NameImpl var2 = (NameImpl)var1;
  342.          if (var2.size() == this.size()) {
  343.             Enumeration var3 = this.getAll();
  344.             Enumeration var4 = var2.getAll();
  345.  
  346.             while(var3.hasMoreElements()) {
  347.                String var5 = (String)var3.nextElement();
  348.                String var6 = (String)var4.nextElement();
  349.                if (this.syntaxTrimBlanks) {
  350.                   var5 = var5.trim();
  351.                   var6 = var6.trim();
  352.                }
  353.  
  354.                if (this.syntaxCaseInsensitive) {
  355.                   if (!var5.equalsIgnoreCase(var6)) {
  356.                      return false;
  357.                   }
  358.                } else if (!var5.equals(var6)) {
  359.                   return false;
  360.                }
  361.             }
  362.  
  363.             return true;
  364.          }
  365.       }
  366.  
  367.       return false;
  368.    }
  369.  
  370.    public int compareTo(NameImpl var1) {
  371.       if (this == var1) {
  372.          return 0;
  373.       } else {
  374.          int var2 = this.size();
  375.          int var3 = var1.size();
  376.          int var4 = Math.min(var2, var3);
  377.          int var5 = 0;
  378.          int var6 = 0;
  379.  
  380.          while(var4-- != 0) {
  381.             String var7 = this.get(var5++);
  382.             String var8 = var1.get(var6++);
  383.             if (this.syntaxTrimBlanks) {
  384.                var7 = var7.trim();
  385.                var8 = var8.trim();
  386.             }
  387.  
  388.             if (this.syntaxCaseInsensitive) {
  389.                var7 = var7.toLowerCase();
  390.                var8 = var8.toLowerCase();
  391.             }
  392.  
  393.             int var9 = var7.compareTo(var8);
  394.             if (var9 != 0) {
  395.                return var9;
  396.             }
  397.          }
  398.  
  399.          return var2 - var3;
  400.       }
  401.    }
  402.  
  403.    public int size() {
  404.       return this.components.size();
  405.    }
  406.  
  407.    public Enumeration getAll() {
  408.       return this.components.elements();
  409.    }
  410.  
  411.    public String get(int var1) {
  412.       return (String)this.components.elementAt(var1);
  413.    }
  414.  
  415.    public Enumeration getPrefix(int var1) {
  416.       if (var1 >= 0 && var1 <= this.size()) {
  417.          return new NameImplEnumerator(this.components, 0, var1);
  418.       } else {
  419.          throw new ArrayIndexOutOfBoundsException(var1);
  420.       }
  421.    }
  422.  
  423.    public Enumeration getSuffix(int var1) {
  424.       int var2 = this.size();
  425.       if (var1 >= 0 && var1 <= var2) {
  426.          return new NameImplEnumerator(this.components, var1, var2);
  427.       } else {
  428.          throw new ArrayIndexOutOfBoundsException(var1);
  429.       }
  430.    }
  431.  
  432.    public boolean isEmpty() {
  433.       return this.components.isEmpty();
  434.    }
  435.  
  436.    public boolean startsWith(int var1, Enumeration var2) {
  437.       if (var1 >= 0 && var1 <= this.size()) {
  438.          try {
  439.             Enumeration var3 = this.getPrefix(var1);
  440.  
  441.             while(var3.hasMoreElements()) {
  442.                String var4 = (String)var3.nextElement();
  443.                String var5 = (String)var2.nextElement();
  444.                if (this.syntaxTrimBlanks) {
  445.                   var4 = var4.trim();
  446.                   var5 = var5.trim();
  447.                }
  448.  
  449.                if (this.syntaxCaseInsensitive) {
  450.                   if (!var4.equalsIgnoreCase(var5)) {
  451.                      return false;
  452.                   }
  453.                } else if (!var4.equals(var5)) {
  454.                   return false;
  455.                }
  456.             }
  457.  
  458.             return true;
  459.          } catch (NoSuchElementException var6) {
  460.             return false;
  461.          }
  462.       } else {
  463.          return false;
  464.       }
  465.    }
  466.  
  467.    public boolean endsWith(int var1, Enumeration var2) {
  468.       int var3 = this.size() - var1;
  469.       if (var3 >= 0 && var3 <= this.size()) {
  470.          try {
  471.             Enumeration var4 = this.getSuffix(var3);
  472.  
  473.             while(var4.hasMoreElements()) {
  474.                String var5 = (String)var4.nextElement();
  475.                String var6 = (String)var2.nextElement();
  476.                if (this.syntaxTrimBlanks) {
  477.                   var5 = var5.trim();
  478.                   var6 = var6.trim();
  479.                }
  480.  
  481.                if (this.syntaxCaseInsensitive) {
  482.                   if (!var5.equalsIgnoreCase(var6)) {
  483.                      return false;
  484.                   }
  485.                } else if (!var5.equals(var6)) {
  486.                   return false;
  487.                }
  488.             }
  489.  
  490.             return true;
  491.          } catch (NoSuchElementException var7) {
  492.             return false;
  493.          }
  494.       } else {
  495.          return false;
  496.       }
  497.    }
  498.  
  499.    public boolean addAll(Enumeration var1) throws InvalidNameException {
  500.       boolean var2;
  501.       for(var2 = false; var1.hasMoreElements(); var2 = true) {
  502.          try {
  503.             Object var3 = var1.nextElement();
  504.             if (this.size() > 0 && this.syntaxDirection.equals("flat")) {
  505.                throw new InvalidNameException("A flat name can only have a single component");
  506.             }
  507.  
  508.             this.components.addElement(var3);
  509.          } catch (NoSuchElementException var4) {
  510.             break;
  511.          }
  512.       }
  513.  
  514.       return var2;
  515.    }
  516.  
  517.    public boolean addAll(int var1, Enumeration var2) throws InvalidNameException {
  518.       boolean var3 = false;
  519.  
  520.       for(int var4 = var1; var2.hasMoreElements(); ++var4) {
  521.          try {
  522.             Object var5 = var2.nextElement();
  523.             if (this.size() > 0 && this.syntaxDirection.equals("flat")) {
  524.                throw new InvalidNameException("A flat name can only have a single component");
  525.             }
  526.  
  527.             this.components.insertElementAt(var5, var4);
  528.             var3 = true;
  529.          } catch (NoSuchElementException var6) {
  530.             break;
  531.          }
  532.       }
  533.  
  534.       return var3;
  535.    }
  536.  
  537.    public void add(String var1) throws InvalidNameException {
  538.       if (this.size() > 0 && this.syntaxDirection.equals("flat")) {
  539.          throw new InvalidNameException("A flat name can only have a single component");
  540.       } else {
  541.          this.components.addElement(var1);
  542.       }
  543.    }
  544.  
  545.    public void add(int var1, String var2) throws InvalidNameException {
  546.       if (this.size() > 0 && this.syntaxDirection.equals("flat")) {
  547.          throw new InvalidNameException("A flat name can only zero or one component");
  548.       } else {
  549.          this.components.insertElementAt(var2, var1);
  550.       }
  551.    }
  552.  
  553.    public Object remove(int var1) {
  554.       Object var2 = this.components.elementAt(var1);
  555.       this.components.removeElementAt(var1);
  556.       return var2;
  557.    }
  558.  
  559.    public int hashCode() {
  560.       int var1 = 0;
  561.  
  562.       for(Enumeration var2 = this.getAll(); var2.hasMoreElements(); var1 += var2.nextElement().hashCode()) {
  563.       }
  564.  
  565.       return var1;
  566.    }
  567. }
  568.