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    }