< prev index next >

src/share/classes/javax/swing/MultiUIDefaults.java

Print this page
rev 1527 : 6727662: Code improvement and warnings removing from swing packages
Summary: Removed unnecessary castings and other warnings
Reviewed-by: malenkov


  43     private UIDefaults[] tables;
  44 
  45     public MultiUIDefaults(UIDefaults[] defaults) {
  46         super();
  47         tables = defaults;
  48     }
  49 
  50     public MultiUIDefaults() {
  51         super();
  52         tables = new UIDefaults[0];
  53     }
  54 
  55     @Override
  56     public Object get(Object key)
  57     {
  58         Object value = super.get(key);
  59         if (value != null) {
  60             return value;
  61         }
  62 
  63         for(int i = 0; i < tables.length; i++) {
  64             UIDefaults table = tables[i];
  65             value = (table != null) ? table.get(key) : null;
  66             if (value != null) {
  67                 return value;
  68             }
  69         }
  70 
  71         return null;
  72     }
  73 
  74     @Override
  75     public Object get(Object key, Locale l)
  76     {
  77         Object value = super.get(key,l);
  78         if (value != null) {
  79             return value;
  80         }
  81 
  82         for(int i = 0; i < tables.length; i++) {
  83             UIDefaults table = tables[i];
  84             value = (table != null) ? table.get(key,l) : null;
  85             if (value != null) {
  86                 return value;
  87             }
  88         }
  89 
  90         return null;
  91     }
  92 
  93     @Override
  94     public int size() {
  95         return entrySet().size();
  96     }
  97 
  98     @Override
  99     public boolean isEmpty() {
 100         return size() == 0;
 101     }
 102 
 103     @Override
 104     public Enumeration keys()
 105     {
 106         return new MultiUIDefaultsEnumerator(
 107                 MultiUIDefaultsEnumerator.Type.KEYS, entrySet());
 108     }
 109 
 110 
 111     @Override
 112     public Enumeration elements()
 113     {
 114         return new MultiUIDefaultsEnumerator(
 115                 MultiUIDefaultsEnumerator.Type.ELEMENTS, entrySet());
 116     }
 117 
 118     @Override
 119     public Set<Entry<Object, Object>> entrySet() {
 120         Set<Entry<Object, Object>> set = new HashSet<Entry<Object, Object>>();
 121         for (int i = tables.length - 1; i >= 0; i--) {
 122             if (tables[i] != null) {
 123                 set.addAll(tables[i].entrySet());
 124             }
 125         }
 126         set.addAll(super.entrySet());
 127         return set;
 128     }
 129 
 130     @Override
 131     protected void getUIError(String msg) {
 132         if (tables.length > 0) {
 133             tables[0].getUIError(msg);
 134         } else {
 135             super.getUIError(msg);
 136         }
 137     }
 138 
 139     private static class MultiUIDefaultsEnumerator implements Enumeration
 140     {
 141         public static enum Type { KEYS, ELEMENTS };
 142         private Iterator<Entry<Object, Object>> iterator;
 143         private Type type;
 144 
 145         MultiUIDefaultsEnumerator(Type type, Set<Entry<Object, Object>> entries) {
 146             this.type = type;
 147             this.iterator = entries.iterator();
 148         }
 149 
 150         public boolean hasMoreElements() {
 151             return iterator.hasNext();
 152         }
 153 
 154         public Object nextElement() {
 155             switch (type) {
 156                 case KEYS: return iterator.next().getKey();
 157                 case ELEMENTS: return iterator.next().getValue();
 158                 default: return null;
 159             }


 166         Object value = null;
 167         for (int i = tables.length - 1; i >= 0; i--) {
 168             if (tables[i] != null) {
 169                 Object v = tables[i].remove(key);
 170                 if (v != null) {
 171                     value = v;
 172                 }
 173             }
 174         }
 175         Object v = super.remove(key);
 176         if (v != null) {
 177             value = v;
 178         }
 179 
 180         return value;
 181     }
 182 
 183     @Override
 184     public void clear() {
 185         super.clear();
 186         for(int i = 0; i < tables.length; i++) {
 187             UIDefaults table = tables[i];
 188             if (table != null) {
 189                 table.clear();
 190             }
 191         }
 192     }
 193 
 194     @Override
 195     public synchronized String toString() {
 196         StringBuffer buf = new StringBuffer();
 197         buf.append("{");
 198         Enumeration keys = keys();
 199         while (keys.hasMoreElements()) {
 200             Object key = keys.nextElement();
 201             buf.append(key + "=" + get(key) + ", ");
 202         }
 203         int length = buf.length();
 204         if (length > 1) {
 205             buf.delete(length-2, length);
 206         }
 207         buf.append("}");


  43     private UIDefaults[] tables;
  44 
  45     public MultiUIDefaults(UIDefaults[] defaults) {
  46         super();
  47         tables = defaults;
  48     }
  49 
  50     public MultiUIDefaults() {
  51         super();
  52         tables = new UIDefaults[0];
  53     }
  54 
  55     @Override
  56     public Object get(Object key)
  57     {
  58         Object value = super.get(key);
  59         if (value != null) {
  60             return value;
  61         }
  62 
  63         for (UIDefaults table : tables) {

  64             value = (table != null) ? table.get(key) : null;
  65             if (value != null) {
  66                 return value;
  67             }
  68         }
  69 
  70         return null;
  71     }
  72 
  73     @Override
  74     public Object get(Object key, Locale l)
  75     {
  76         Object value = super.get(key,l);
  77         if (value != null) {
  78             return value;
  79         }
  80 
  81         for (UIDefaults table : tables) {

  82             value = (table != null) ? table.get(key,l) : null;
  83             if (value != null) {
  84                 return value;
  85             }
  86         }
  87 
  88         return null;
  89     }
  90 
  91     @Override
  92     public int size() {
  93         return entrySet().size();
  94     }
  95 
  96     @Override
  97     public boolean isEmpty() {
  98         return size() == 0;
  99     }
 100 
 101     @Override
 102     public Enumeration<Object> keys()
 103     {
 104         return new MultiUIDefaultsEnumerator(
 105                 MultiUIDefaultsEnumerator.Type.KEYS, entrySet());
 106     }
 107 
 108 
 109     @Override
 110     public Enumeration<Object> elements()
 111     {
 112         return new MultiUIDefaultsEnumerator(
 113                 MultiUIDefaultsEnumerator.Type.ELEMENTS, entrySet());
 114     }
 115 
 116     @Override
 117     public Set<Entry<Object, Object>> entrySet() {
 118         Set<Entry<Object, Object>> set = new HashSet<Entry<Object, Object>>();
 119         for (int i = tables.length - 1; i >= 0; i--) {
 120             if (tables[i] != null) {
 121                 set.addAll(tables[i].entrySet());
 122             }
 123         }
 124         set.addAll(super.entrySet());
 125         return set;
 126     }
 127 
 128     @Override
 129     protected void getUIError(String msg) {
 130         if (tables.length > 0) {
 131             tables[0].getUIError(msg);
 132         } else {
 133             super.getUIError(msg);
 134         }
 135     }
 136 
 137     private static class MultiUIDefaultsEnumerator implements Enumeration<Object>
 138     {
 139         public static enum Type { KEYS, ELEMENTS };
 140         private Iterator<Entry<Object, Object>> iterator;
 141         private Type type;
 142 
 143         MultiUIDefaultsEnumerator(Type type, Set<Entry<Object, Object>> entries) {
 144             this.type = type;
 145             this.iterator = entries.iterator();
 146         }
 147 
 148         public boolean hasMoreElements() {
 149             return iterator.hasNext();
 150         }
 151 
 152         public Object nextElement() {
 153             switch (type) {
 154                 case KEYS: return iterator.next().getKey();
 155                 case ELEMENTS: return iterator.next().getValue();
 156                 default: return null;
 157             }


 164         Object value = null;
 165         for (int i = tables.length - 1; i >= 0; i--) {
 166             if (tables[i] != null) {
 167                 Object v = tables[i].remove(key);
 168                 if (v != null) {
 169                     value = v;
 170                 }
 171             }
 172         }
 173         Object v = super.remove(key);
 174         if (v != null) {
 175             value = v;
 176         }
 177 
 178         return value;
 179     }
 180 
 181     @Override
 182     public void clear() {
 183         super.clear();
 184         for (UIDefaults table : tables) {

 185             if (table != null) {
 186                 table.clear();
 187             }
 188         }
 189     }
 190 
 191     @Override
 192     public synchronized String toString() {
 193         StringBuffer buf = new StringBuffer();
 194         buf.append("{");
 195         Enumeration keys = keys();
 196         while (keys.hasMoreElements()) {
 197             Object key = keys.nextElement();
 198             buf.append(key + "=" + get(key) + ", ");
 199         }
 200         int length = buf.length();
 201         if (length > 1) {
 202             buf.delete(length-2, length);
 203         }
 204         buf.append("}");
< prev index next >