001 package railo.runtime.text.xml.struct; 002 003 import java.util.ArrayList; 004 import java.util.Comparator; 005 import java.util.Iterator; 006 import java.util.List; 007 import java.util.Map.Entry; 008 009 import org.w3c.dom.Element; 010 import org.w3c.dom.Node; 011 012 import railo.runtime.PageContext; 013 import railo.runtime.dump.DumpData; 014 import railo.runtime.dump.DumpProperties; 015 import railo.runtime.exp.PageException; 016 import railo.runtime.exp.PageRuntimeException; 017 import railo.runtime.op.Duplicator; 018 import railo.runtime.text.xml.XMLCaster; 019 import railo.runtime.type.Collection; 020 import railo.runtime.type.dt.DateTime; 021 import railo.runtime.type.it.EntryIterator; 022 import railo.runtime.type.it.KeyIterator; 023 import railo.runtime.type.it.StringIterator; 024 import railo.runtime.type.util.ArraySupport; 025 import railo.runtime.type.util.ArrayUtil; 026 import railo.runtime.type.wrap.ArrayAsArrayList; 027 028 public class XMLMultiElementArray extends ArraySupport { 029 030 private static final long serialVersionUID = -2673749147723742450L; 031 private XMLMultiElementStruct struct; 032 033 public XMLMultiElementArray(XMLMultiElementStruct struct) { 034 this.struct=struct; 035 } 036 037 @Override 038 public Object append(Object o) throws PageException { 039 return setE(size()+1,o); 040 } 041 042 @Override 043 public Object appendEL(Object o) { 044 return setEL(size()+1,o); 045 } 046 047 048 @Override 049 public boolean containsKey(int key) { 050 return get(key,null)!=null; 051 } 052 053 @Override 054 public Object get(int key, Object defaultValue) { 055 return struct.get(key,defaultValue); 056 } 057 058 @Override 059 public Object getE(int key) throws PageException { 060 return struct.get(key); 061 } 062 063 064 @Override 065 public int getDimension() { 066 return struct.getInnerArray().getDimension(); 067 } 068 069 @Override 070 public boolean insert(int index, Object value) throws PageException { 071 Element element=XMLCaster.toElement(struct.getOwnerDocument(),value); 072 boolean rtn = struct.getInnerArray().insert(index, element); 073 Object obj = struct.getInnerArray().get(index,null); 074 075 if(obj instanceof Element) { 076 Element el = ((Element)obj); 077 el.getParentNode().insertBefore(XMLCaster.toRawNode(element), el); 078 } 079 else { 080 struct.getParentNode().appendChild(XMLCaster.toRawNode(element)); 081 } 082 return rtn; 083 } 084 085 @Override 086 public int[] intKeys() { 087 return struct.getInnerArray().intKeys(); 088 } 089 090 @Override 091 public Object prepend(Object value) throws PageException { 092 Element element=XMLCaster.toElement(struct.getOwnerDocument(),value); 093 Object obj = struct.getInnerArray().get(1,null); 094 095 if(obj instanceof Element) { 096 Element el = ((Element)obj); 097 el.getParentNode().insertBefore(XMLCaster.toRawNode(element), el); 098 } 099 else { 100 struct.getParentNode().appendChild(XMLCaster.toRawNode(element)); 101 } 102 return struct.getInnerArray().prepend(element); 103 } 104 105 @Override 106 public Object removeE(int key) throws PageException { 107 return struct.remove(key); 108 } 109 110 @Override 111 public Object removeEL(int key) { 112 return struct.removeEL(key); 113 } 114 115 @Override 116 public void resize(int to) throws PageException { 117 throw new PageRuntimeException("resizing of xml nodelist not allowed"); 118 } 119 120 @Override 121 public Object setE(int key, Object value) throws PageException { 122 return struct.set(key, value); 123 } 124 125 @Override 126 public Object setEL(int key, Object value) { 127 return struct.setEL(key, value); 128 } 129 130 @Override 131 public void sort(String sortType, String sortOrder) throws PageException { 132 if(size()<=1) return; 133 134 struct.getInnerArray().sort(sortType, sortOrder); 135 136 Object[] nodes = struct.getInnerArray().toArray(); 137 Node last=(Node) nodes[nodes.length-1],current; 138 Node parent=last.getParentNode(); 139 for(int i=nodes.length-2;i>=0;i--) { 140 current=(Node) nodes[i]; 141 parent.insertBefore(current, last); 142 last=current; 143 }// MUST testen 144 } 145 146 public void sort(Comparator comp) throws PageException { 147 if(size()<=1) return; 148 149 struct.getInnerArray().sort(comp); 150 151 Object[] nodes = struct.getInnerArray().toArray(); 152 Node last=(Node) nodes[nodes.length-1],current; 153 Node parent=last.getParentNode(); 154 for(int i=nodes.length-2;i>=0;i--) { 155 current=(Node) nodes[i]; 156 parent.insertBefore(current, last); 157 last=current; 158 }// MUST testen 159 } 160 161 162 @Override 163 public Object[] toArray() { 164 return struct.getInnerArray().toArray(); 165 } 166 167 public ArrayList toArrayList() { 168 return ArrayAsArrayList.toArrayList(this); 169 } 170 171 @Override 172 public void clear() {//MUST 173 } 174 175 @Override 176 public boolean containsKey(String key) { 177 return struct.containsKey(key); 178 } 179 180 @Override 181 public boolean containsKey(Key key) { 182 return struct.containsKey(key); 183 } 184 185 @Override 186 public Collection duplicate(boolean deepCopy) { 187 return new XMLMultiElementArray((XMLMultiElementStruct)Duplicator.duplicate(struct,deepCopy)); 188 } 189 190 191 @Override 192 public Object get(String key) throws PageException { 193 return struct.get(key); 194 } 195 196 @Override 197 public Object get(Key key) throws PageException { 198 return struct.get(key); 199 } 200 201 @Override 202 public Object get(String key, Object defaultValue) { 203 return struct.get(key,defaultValue); 204 } 205 206 @Override 207 public Object get(Key key, Object defaultValue) { 208 return struct.get(key,defaultValue); 209 } 210 211 @Override 212 public Key[] keys() { 213 return struct.getInnerArray().keys(); 214 } 215 216 @Override 217 public Object remove(Key key) throws PageException { 218 return struct.remove(key); 219 } 220 221 @Override 222 public Object removeEL(Key key) { 223 return struct.removeEL(key); 224 } 225 226 @Override 227 public Object set(String key, Object value) throws PageException { 228 return struct.set(key, value); 229 } 230 231 @Override 232 public Object set(Key key, Object value) throws PageException { 233 return struct.set(key, value); 234 } 235 236 @Override 237 public Object setEL(String key, Object value) { 238 return struct.setEL(key, value); 239 } 240 241 @Override 242 public Object setEL(Key key, Object value) { 243 return struct.setEL(key, value); 244 } 245 246 @Override 247 public int size() { 248 return struct.getInnerArray().size(); 249 } 250 251 @Override 252 public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) { 253 return struct.toDumpData(pageContext, maxlevel,dp); 254 } 255 256 @Override 257 public Iterator<Collection.Key> keyIterator() { 258 return new KeyIterator(keys()); 259 } 260 261 @Override 262 public Iterator<String> keysAsStringIterator() { 263 return new StringIterator(keys()); 264 } 265 266 @Override 267 public Iterator<Entry<Key, Object>> entryIterator() { 268 return new EntryIterator(this,keys()); 269 } 270 271 @Override 272 public boolean castToBooleanValue() throws PageException { 273 return struct.castToBooleanValue(); 274 } 275 276 @Override 277 public Boolean castToBoolean(Boolean defaultValue) { 278 return struct.castToBoolean(defaultValue); 279 } 280 281 @Override 282 public DateTime castToDateTime() throws PageException { 283 return struct.castToDateTime(); 284 } 285 286 @Override 287 public DateTime castToDateTime(DateTime defaultValue) { 288 return struct.castToDateTime(defaultValue); 289 } 290 291 @Override 292 public double castToDoubleValue() throws PageException { 293 return struct.castToDoubleValue(); 294 } 295 296 @Override 297 public double castToDoubleValue(double defaultValue) { 298 return struct.castToDoubleValue(defaultValue); 299 } 300 301 @Override 302 public String castToString() throws PageException { 303 return struct.castToString(); 304 } 305 306 @Override 307 public String castToString(String defaultValue) { 308 return struct.castToString(defaultValue); 309 } 310 311 @Override 312 public int compareTo(String str) throws PageException { 313 return struct.compareTo(str); 314 } 315 316 @Override 317 public int compareTo(boolean b) throws PageException { 318 return struct.compareTo(b); 319 } 320 321 @Override 322 public int compareTo(double d) throws PageException { 323 return struct.compareTo(d); 324 } 325 326 @Override 327 public int compareTo(DateTime dt) throws PageException { 328 return struct.compareTo(dt); 329 } 330 331 @Override 332 public Object clone() { 333 return duplicate(true); 334 } 335 336 public boolean add(Object o) { 337 // TODO Auto-generated method stub 338 return false; 339 } 340 341 @Override 342 public long sizeOf() { 343 return ArrayUtil.sizeOf((List)this); 344 } 345 346 }