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 / java / text / AttributedString.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  7.4 KB  |  487 lines
  1. package java.text;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Map;
  5. import java.util.Set;
  6. import java.util.Vector;
  7.  
  8. public class AttributedString {
  9.    private static final int ARRAY_SIZE_INCREMENT = 10;
  10.    String text;
  11.    int runArraySize;
  12.    int runCount;
  13.    int[] runStarts;
  14.    Vector[] runAttributes;
  15.    Vector[] runAttributeValues;
  16.  
  17.    AttributedString(AttributedCharacterIterator[] var1) {
  18.       if (var1 == null) {
  19.          throw new NullPointerException("Iterators must not be null");
  20.       } else {
  21.          if (var1.length == 0) {
  22.             this.text = "";
  23.          } else {
  24.             StringBuffer var2 = new StringBuffer();
  25.  
  26.             for(int var3 = 0; var3 < var1.length; ++var3) {
  27.                this.appendContents(var2, var1[var3]);
  28.             }
  29.  
  30.             this.text = var2.toString();
  31.             if (this.text.length() > 0) {
  32.                int var11 = 0;
  33.                Map var4 = null;
  34.  
  35.                for(int var5 = 0; var5 < var1.length; ++var5) {
  36.                   AttributedCharacterIterator var6 = var1[var5];
  37.                   int var7 = var6.getBeginIndex();
  38.                   int var8 = var6.getEndIndex();
  39.  
  40.                   for(int var9 = var7; var9 < var8; var9 = var6.getRunLimit()) {
  41.                      var6.setIndex(var9);
  42.                      Map var10 = var6.getAttributes();
  43.                      if (mapsDiffer(var4, var10)) {
  44.                         this.setAttributes(var10, var9 - var7 + var11);
  45.                      }
  46.  
  47.                      var4 = var10;
  48.                   }
  49.  
  50.                   var11 += var8 - var7;
  51.                }
  52.             }
  53.          }
  54.  
  55.       }
  56.    }
  57.  
  58.    public AttributedString(String var1) {
  59.       if (var1 == null) {
  60.          throw new NullPointerException();
  61.       } else {
  62.          this.text = var1;
  63.       }
  64.    }
  65.  
  66.    public AttributedString(String var1, Map<? extends AttributedCharacterIterator.Attribute, ?> var2) {
  67.       if (var1 != null && var2 != null) {
  68.          this.text = var1;
  69.          if (var1.length() == 0) {
  70.             if (!var2.isEmpty()) {
  71.                throw new IllegalArgumentException("Can't add attribute to 0-length text");
  72.             }
  73.          } else {
  74.             int var3 = var2.size();
  75.             if (var3 > 0) {
  76.                this.createRunAttributeDataVectors();
  77.                Vector var4 = new Vector(var3);
  78.                Vector var5 = new Vector(var3);
  79.                this.runAttributes[0] = var4;
  80.                this.runAttributeValues[0] = var5;
  81.  
  82.                for(Map.Entry var7 : var2.entrySet()) {
  83.                   var4.addElement(var7.getKey());
  84.                   var5.addElement(var7.getValue());
  85.                }
  86.             }
  87.  
  88.          }
  89.       } else {
  90.          throw new NullPointerException();
  91.       }
  92.    }
  93.  
  94.    public AttributedString(AttributedCharacterIterator var1) {
  95.       this(var1, var1.getBeginIndex(), var1.getEndIndex(), (AttributedCharacterIterator.Attribute[])null);
  96.    }
  97.  
  98.    public AttributedString(AttributedCharacterIterator var1, int var2, int var3) {
  99.       this(var1, var2, var3, (AttributedCharacterIterator.Attribute[])null);
  100.    }
  101.  
  102.    public AttributedString(AttributedCharacterIterator var1, int var2, int var3, AttributedCharacterIterator.Attribute[] var4) {
  103.       if (var1 == null) {
  104.          throw new NullPointerException();
  105.       } else {
  106.          int var5 = var1.getBeginIndex();
  107.          int var6 = var1.getEndIndex();
  108.          if (var2 >= var5 && var3 <= var6 && var2 <= var3) {
  109.             StringBuffer var7 = new StringBuffer();
  110.             var1.setIndex(var2);
  111.  
  112.             for(char var8 = var1.current(); var1.getIndex() < var3; var8 = var1.next()) {
  113.                var7.append(var8);
  114.             }
  115.  
  116.             this.text = var7.toString();
  117.             if (var2 != var3) {
  118.                HashSet var14 = new HashSet();
  119.                if (var4 == null) {
  120.                   var14.addAll(var1.getAllAttributeKeys());
  121.                } else {
  122.                   for(int var9 = 0; var9 < var4.length; ++var9) {
  123.                      var14.add(var4[var9]);
  124.                   }
  125.  
  126.                   var14.retainAll(var1.getAllAttributeKeys());
  127.                }
  128.  
  129.                if (!var14.isEmpty()) {
  130.                   for(AttributedCharacterIterator.Attribute var10 : var14) {
  131.                      var1.setIndex(var5);
  132.  
  133.                      int var12;
  134.                      for(; var1.getIndex() < var3; var1.setIndex(var12)) {
  135.                         int var11 = var1.getRunStart(var10);
  136.                         var12 = var1.getRunLimit(var10);
  137.                         Object var13 = var1.getAttribute(var10);
  138.                         if (var13 != null) {
  139.                            if (var13 instanceof Annotation) {
  140.                               if (var11 >= var2 && var12 <= var3) {
  141.                                  this.addAttribute(var10, var13, var11 - var2, var12 - var2);
  142.                               } else if (var12 > var3) {
  143.                                  break;
  144.                               }
  145.                            } else {
  146.                               if (var11 >= var3) {
  147.                                  break;
  148.                               }
  149.  
  150.                               if (var12 > var2) {
  151.                                  if (var11 < var2) {
  152.                                     var11 = var2;
  153.                                  }
  154.  
  155.                                  if (var12 > var3) {
  156.                                     var12 = var3;
  157.                                  }
  158.  
  159.                                  if (var11 != var12) {
  160.                                     this.addAttribute(var10, var13, var11 - var2, var12 - var2);
  161.                                  }
  162.                               }
  163.                            }
  164.                         }
  165.                      }
  166.                   }
  167.  
  168.                }
  169.             }
  170.          } else {
  171.             throw new IllegalArgumentException("Invalid substring range");
  172.          }
  173.       }
  174.    }
  175.  
  176.    public void addAttribute(AttributedCharacterIterator.Attribute var1, Object var2) {
  177.       if (var1 == null) {
  178.          throw new NullPointerException();
  179.       } else {
  180.          int var3 = this.length();
  181.          if (var3 == 0) {
  182.             throw new IllegalArgumentException("Can't add attribute to 0-length text");
  183.          } else {
  184.             this.addAttributeImpl(var1, var2, 0, var3);
  185.          }
  186.       }
  187.    }
  188.  
  189.    public void addAttribute(AttributedCharacterIterator.Attribute var1, Object var2, int var3, int var4) {
  190.       if (var1 == null) {
  191.          throw new NullPointerException();
  192.       } else if (var3 >= 0 && var4 <= this.length() && var3 < var4) {
  193.          this.addAttributeImpl(var1, var2, var3, var4);
  194.       } else {
  195.          throw new IllegalArgumentException("Invalid substring range");
  196.       }
  197.    }
  198.  
  199.    public void addAttributes(Map<? extends AttributedCharacterIterator.Attribute, ?> var1, int var2, int var3) {
  200.       if (var1 == null) {
  201.          throw new NullPointerException();
  202.       } else if (var2 >= 0 && var3 <= this.length() && var2 <= var3) {
  203.          if (var2 == var3) {
  204.             if (!var1.isEmpty()) {
  205.                throw new IllegalArgumentException("Can't add attribute to 0-length text");
  206.             }
  207.          } else {
  208.             if (this.runCount == 0) {
  209.                this.createRunAttributeDataVectors();
  210.             }
  211.  
  212.             int var4 = this.ensureRunBreak(var2);
  213.             int var5 = this.ensureRunBreak(var3);
  214.  
  215.             for(Map.Entry var7 : var1.entrySet()) {
  216.                this.addAttributeRunData((AttributedCharacterIterator.Attribute)var7.getKey(), var7.getValue(), var4, var5);
  217.             }
  218.  
  219.          }
  220.       } else {
  221.          throw new IllegalArgumentException("Invalid substring range");
  222.       }
  223.    }
  224.  
  225.    private synchronized void addAttributeImpl(AttributedCharacterIterator.Attribute var1, Object var2, int var3, int var4) {
  226.       if (this.runCount == 0) {
  227.          this.createRunAttributeDataVectors();
  228.       }
  229.  
  230.       int var5 = this.ensureRunBreak(var3);
  231.       int var6 = this.ensureRunBreak(var4);
  232.       this.addAttributeRunData(var1, var2, var5, var6);
  233.    }
  234.  
  235.    private final void createRunAttributeDataVectors() {
  236.       int[] var1 = new int[10];
  237.       Vector[] var2 = new Vector[10];
  238.       Vector[] var3 = new Vector[10];
  239.       this.runStarts = var1;
  240.       this.runAttributes = var2;
  241.       this.runAttributeValues = var3;
  242.       this.runArraySize = 10;
  243.       this.runCount = 1;
  244.    }
  245.  
  246.    private final int ensureRunBreak(int var1) {
  247.       return this.ensureRunBreak(var1, true);
  248.    }
  249.  
  250.    private final int ensureRunBreak(int var1, boolean var2) {
  251.       if (var1 == this.length()) {
  252.          return this.runCount;
  253.       } else {
  254.          int var3;
  255.          for(var3 = 0; var3 < this.runCount && this.runStarts[var3] < var1; ++var3) {
  256.          }
  257.  
  258.          if (var3 < this.runCount && this.runStarts[var3] == var1) {
  259.             return var3;
  260.          } else {
  261.             if (this.runCount == this.runArraySize) {
  262.                int var4 = this.runArraySize + 10;
  263.                int[] var5 = new int[var4];
  264.                Vector[] var6 = new Vector[var4];
  265.                Vector[] var7 = new Vector[var4];
  266.  
  267.                for(int var8 = 0; var8 < this.runArraySize; ++var8) {
  268.                   var5[var8] = this.runStarts[var8];
  269.                   var6[var8] = this.runAttributes[var8];
  270.                   var7[var8] = this.runAttributeValues[var8];
  271.                }
  272.  
  273.                this.runStarts = var5;
  274.                this.runAttributes = var6;
  275.                this.runAttributeValues = var7;
  276.                this.runArraySize = var4;
  277.             }
  278.  
  279.             Vector var9 = null;
  280.             Vector var10 = null;
  281.             if (var2) {
  282.                Vector var11 = this.runAttributes[var3 - 1];
  283.                Vector var13 = this.runAttributeValues[var3 - 1];
  284.                if (var11 != null) {
  285.                   var9 = (Vector)var11.clone();
  286.                }
  287.  
  288.                if (var13 != null) {
  289.                   var10 = (Vector)var13.clone();
  290.                }
  291.             }
  292.  
  293.             ++this.runCount;
  294.  
  295.             for(int var12 = this.runCount - 1; var12 > var3; --var12) {
  296.                this.runStarts[var12] = this.runStarts[var12 - 1];
  297.                this.runAttributes[var12] = this.runAttributes[var12 - 1];
  298.                this.runAttributeValues[var12] = this.runAttributeValues[var12 - 1];
  299.             }
  300.  
  301.             this.runStarts[var3] = var1;
  302.             this.runAttributes[var3] = var9;
  303.             this.runAttributeValues[var3] = var10;
  304.             return var3;
  305.          }
  306.       }
  307.    }
  308.  
  309.    private void addAttributeRunData(AttributedCharacterIterator.Attribute var1, Object var2, int var3, int var4) {
  310.       for(int var5 = var3; var5 < var4; ++var5) {
  311.          int var6 = -1;
  312.          if (this.runAttributes[var5] == null) {
  313.             Vector var7 = new Vector();
  314.             Vector var8 = new Vector();
  315.             this.runAttributes[var5] = var7;
  316.             this.runAttributeValues[var5] = var8;
  317.          } else {
  318.             var6 = this.runAttributes[var5].indexOf(var1);
  319.          }
  320.  
  321.          if (var6 == -1) {
  322.             int var10 = this.runAttributes[var5].size();
  323.             this.runAttributes[var5].addElement(var1);
  324.  
  325.             try {
  326.                this.runAttributeValues[var5].addElement(var2);
  327.             } catch (Exception var9) {
  328.                this.runAttributes[var5].setSize(var10);
  329.                this.runAttributeValues[var5].setSize(var10);
  330.             }
  331.          } else {
  332.             this.runAttributeValues[var5].set(var6, var2);
  333.          }
  334.       }
  335.  
  336.    }
  337.  
  338.    public AttributedCharacterIterator getIterator() {
  339.       return this.getIterator((AttributedCharacterIterator.Attribute[])null, 0, this.length());
  340.    }
  341.  
  342.    public AttributedCharacterIterator getIterator(AttributedCharacterIterator.Attribute[] var1) {
  343.       return this.getIterator(var1, 0, this.length());
  344.    }
  345.  
  346.    public AttributedCharacterIterator getIterator(AttributedCharacterIterator.Attribute[] var1, int var2, int var3) {
  347.       return new AttributedStringIterator(this, var1, var2, var3);
  348.    }
  349.  
  350.    int length() {
  351.       return this.text.length();
  352.    }
  353.  
  354.    private char charAt(int var1) {
  355.       return this.text.charAt(var1);
  356.    }
  357.  
  358.    private synchronized Object getAttribute(AttributedCharacterIterator.Attribute var1, int var2) {
  359.       Vector var3 = this.runAttributes[var2];
  360.       Vector var4 = this.runAttributeValues[var2];
  361.       if (var3 == null) {
  362.          return null;
  363.       } else {
  364.          int var5 = var3.indexOf(var1);
  365.          return var5 != -1 ? var4.elementAt(var5) : null;
  366.       }
  367.    }
  368.  
  369.    private Object getAttributeCheckRange(AttributedCharacterIterator.Attribute var1, int var2, int var3, int var4) {
  370.       Object var5 = this.getAttribute(var1, var2);
  371.       if (var5 instanceof Annotation) {
  372.          if (var3 > 0) {
  373.             int var6 = var2;
  374.  
  375.             int var7;
  376.             for(var7 = this.runStarts[var2]; var7 >= var3 && valuesMatch(var5, this.getAttribute(var1, var6 - 1)); var7 = this.runStarts[var6]) {
  377.                --var6;
  378.             }
  379.  
  380.             if (var7 < var3) {
  381.                return null;
  382.             }
  383.          }
  384.  
  385.          int var9 = this.length();
  386.          if (var4 < var9) {
  387.             int var10 = var2;
  388.  
  389.             int var8;
  390.             for(var8 = var2 < this.runCount - 1 ? this.runStarts[var2 + 1] : var9; var8 <= var4 && valuesMatch(var5, this.getAttribute(var1, var10 + 1)); var8 = var10 < this.runCount - 1 ? this.runStarts[var10 + 1] : var9) {
  391.                ++var10;
  392.             }
  393.  
  394.             if (var8 > var4) {
  395.                return null;
  396.             }
  397.          }
  398.       }
  399.  
  400.       return var5;
  401.    }
  402.  
  403.    private boolean attributeValuesMatch(Set var1, int var2, int var3) {
  404.       for(AttributedCharacterIterator.Attribute var5 : var1) {
  405.          if (!valuesMatch(this.getAttribute(var5, var2), this.getAttribute(var5, var3))) {
  406.             return false;
  407.          }
  408.       }
  409.  
  410.       return true;
  411.    }
  412.  
  413.    private static final boolean valuesMatch(Object var0, Object var1) {
  414.       if (var0 == null) {
  415.          return var1 == null;
  416.       } else {
  417.          return var0.equals(var1);
  418.       }
  419.    }
  420.  
  421.    private final void appendContents(StringBuffer var1, CharacterIterator var2) {
  422.       int var3 = var2.getBeginIndex();
  423.       int var4 = var2.getEndIndex();
  424.  
  425.       while(var3 < var4) {
  426.          var2.setIndex(var3++);
  427.          var1.append(var2.current());
  428.       }
  429.  
  430.    }
  431.  
  432.    private void setAttributes(Map var1, int var2) {
  433.       if (this.runCount == 0) {
  434.          this.createRunAttributeDataVectors();
  435.       }
  436.  
  437.       int var3 = this.ensureRunBreak(var2, false);
  438.       int var4;
  439.       if (var1 != null && (var4 = var1.size()) > 0) {
  440.          Vector var5 = new Vector(var4);
  441.          Vector var6 = new Vector(var4);
  442.  
  443.          for(Map.Entry var8 : var1.entrySet()) {
  444.             var5.add(var8.getKey());
  445.             var6.add(var8.getValue());
  446.          }
  447.  
  448.          this.runAttributes[var3] = var5;
  449.          this.runAttributeValues[var3] = var6;
  450.       }
  451.  
  452.    }
  453.  
  454.    private static boolean mapsDiffer(Map var0, Map var1) {
  455.       if (var0 != null) {
  456.          return !var0.equals(var1);
  457.       } else {
  458.          return var1 != null && var1.size() > 0;
  459.       }
  460.    }
  461.  
  462.    // $FF: synthetic method
  463.    static char access$000(AttributedString var0, int var1) {
  464.       return var0.charAt(var1);
  465.    }
  466.  
  467.    // $FF: synthetic method
  468.    static Object access$100(AttributedString var0, AttributedCharacterIterator.Attribute var1, int var2) {
  469.       return var0.getAttribute(var1, var2);
  470.    }
  471.  
  472.    // $FF: synthetic method
  473.    static boolean access$200(Object var0, Object var1) {
  474.       return valuesMatch(var0, var1);
  475.    }
  476.  
  477.    // $FF: synthetic method
  478.    static boolean access$300(AttributedString var0, Set var1, int var2, int var3) {
  479.       return var0.attributeValuesMatch(var1, var2, var3);
  480.    }
  481.  
  482.    // $FF: synthetic method
  483.    static Object access$400(AttributedString var0, AttributedCharacterIterator.Attribute var1, int var2, int var3, int var4) {
  484.       return var0.getAttributeCheckRange(var1, var2, var3, var4);
  485.    }
  486. }
  487.