001    package railo.runtime.type.scope;
002    
003    import java.util.Comparator;
004    import java.util.Iterator;
005    import java.util.List;
006    import java.util.Map;
007    import java.util.Set;
008    
009    import railo.commons.lang.CFTypes;
010    import railo.runtime.PageContext;
011    import railo.runtime.dump.DumpData;
012    import railo.runtime.dump.DumpProperties;
013    import railo.runtime.exp.CasterException;
014    import railo.runtime.exp.ExpressionException;
015    import railo.runtime.exp.PageException;
016    import railo.runtime.exp.PageRuntimeException;
017    import railo.runtime.op.Caster;
018    import railo.runtime.op.Duplicator;
019    import railo.runtime.type.Collection;
020    import railo.runtime.type.KeyImpl;
021    import railo.runtime.type.Sizeable;
022    import railo.runtime.type.Struct;
023    import railo.runtime.type.dt.DateTime;
024    import railo.runtime.type.util.MemberUtil;
025    import railo.runtime.type.util.StructUtil;
026    
027    public final class ArgumentThreadImpl implements Argument,Sizeable {
028    
029            private final Struct sct;
030    
031            public ArgumentThreadImpl(Struct sct){
032                    this.sct=sct;
033            }
034            
035            @Override
036            public Object getFunctionArgument(String key, Object defaultValue) {
037                    return sct.get(key,defaultValue);
038            }
039    
040            @Override
041            public Object getFunctionArgument(Key key, Object defaultValue) {
042                    return sct.get(key,defaultValue);
043            }
044            
045    
046    
047            @Override
048            public boolean containsFunctionArgumentKey(Key key) {
049                    return sct.containsKey(key);
050            }
051    
052            public Object setArgument(Object obj) throws PageException {
053                    // TODO Auto-generated method stub
054                    return null;
055            }
056    
057            @Override
058            public void setFunctionArgumentNames(Set functionArgumentNames) {
059                    
060            }
061    
062            public boolean insert(int index, String key, Object value) throws PageException {
063                    // TODO Auto-generated method stub
064                    return false;
065            }
066    
067            @Override
068            public boolean isBind() {
069                    return true;
070            }
071    
072            @Override
073            public void setBind(boolean bind) {
074                    
075            }
076    
077            @Override
078            public int getType() {
079                    return SCOPE_ARGUMENTS;
080            }
081    
082            @Override
083            public String getTypeAsString() {
084                    return "arguments";
085            }
086    
087            @Override
088            public void initialize(PageContext pc) {
089            }
090    
091            @Override
092            public boolean isInitalized() {
093                    return true;
094            }
095    
096            @Override
097            public void release() {}
098            public void release(PageContext pc) {}
099    
100            @Override
101            public void clear() {
102                    sct.clear();
103            }
104    
105            @Override
106            public boolean containsKey(String key) {
107                    return sct.containsKey(key);
108            }
109    
110            @Override
111            public boolean containsKey(Key key) {
112                    return sct.containsKey(key);
113            }
114    
115            @Override
116            public Collection duplicate(boolean deepCopy) {
117                    return new ArgumentThreadImpl((Struct)Duplicator.duplicate(sct,deepCopy));
118            }
119    
120            @Override
121            public Object get(String key) throws PageException {
122                    return get(KeyImpl.init(key));
123            }
124    
125            @Override
126            public Object get(Key key) throws PageException {
127                    return sct.get(key);
128            }
129    
130            @Override
131            public Object get(String key, Object defaultValue) {
132                    return sct.get(key, defaultValue);
133            }
134    
135            @Override
136            public Object get(Key key, Object defaultValue) {
137                    return sct.get(key, defaultValue);
138            }
139    
140            @Override
141            public Key[] keys() {
142                    return sct.keys();
143            }
144    
145            @Override
146            public Object remove(Key key) throws PageException {
147                    return sct.remove(key);
148            }
149    
150            @Override
151            public Object removeEL(Key key) {
152                    return sct.removeEL(key);
153            }
154    
155            @Override
156            public Object set(String key, Object value) throws PageException {
157                    return sct.set(key, value);
158            }
159    
160            @Override
161            public Object set(Key key, Object value) throws PageException {
162                    return sct.set(key, value);
163            }
164    
165            @Override
166            public Object setEL(String key, Object value) {
167                    return sct.setEL(key, value);
168            }
169    
170            @Override
171            public Object setEL(Key key, Object value) {
172                    return sct.setEL(key, value);
173            }
174    
175            @Override
176            public int size() {
177                    return sct.size();
178            }
179    
180            @Override
181            public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties properties) {
182                    return sct.toDumpData(pageContext, maxlevel, properties);
183            }
184    
185            @Override
186            public Iterator<Collection.Key> keyIterator() {
187                    return sct.keyIterator();
188            }
189        
190        @Override
191            public Iterator<String> keysAsStringIterator() {
192            return sct.keysAsStringIterator();
193        }
194            
195            @Override
196            public Iterator<Entry<Key, Object>> entryIterator() {
197                    return sct.entryIterator();
198            }
199    
200            @Override
201            public Iterator<Object> valueIterator() {
202                    return sct.valueIterator();
203            }
204    
205            public Boolean castToBoolean(Boolean defaultValue) {
206                    return sct.castToBoolean(defaultValue);
207            }
208    
209            @Override
210            public boolean castToBooleanValue() throws PageException {
211                    return sct.castToBooleanValue();
212            }
213    
214            @Override
215            public DateTime castToDateTime() throws PageException {
216                    return sct.castToDateTime();
217            }
218    
219            @Override
220            public DateTime castToDateTime(DateTime defaultValue) {
221                    return sct.castToDateTime(defaultValue);
222            }
223    
224            @Override
225            public double castToDoubleValue() throws PageException {
226                    return sct.castToDoubleValue();
227            }
228    
229            @Override
230            public double castToDoubleValue(double defaultValue) {
231                    return sct.castToDoubleValue(defaultValue);
232            }
233    
234            @Override
235            public String castToString() throws PageException {
236                    return sct.castToString();
237            }
238    
239            @Override
240            public String castToString(String defaultValue) {
241                    return sct.castToString(defaultValue);
242            }
243    
244            @Override
245            public int compareTo(String str) throws PageException {
246                    return sct.compareTo(str);
247            }
248    
249            @Override
250            public int compareTo(boolean b) throws PageException {
251                    return sct.compareTo(b);
252            }
253    
254            @Override
255            public int compareTo(double d) throws PageException {
256                    return sct.compareTo(d);
257            }
258    
259            @Override
260            public int compareTo(DateTime dt) throws PageException {
261                    return sct.compareTo(dt);
262            }
263    
264            @Override
265            public boolean containsKey(Object key) {
266                    return sct.containsKey(key);
267            }
268    
269            @Override
270            public boolean containsValue(Object value) {
271                    return sct.containsValue(value);
272            }
273    
274            @Override
275            public Set entrySet() {
276                    return sct.entrySet();
277            }
278    
279            @Override
280            public Object get(Object key) {
281                    return sct.get(key);
282            }
283    
284            @Override
285            public boolean isEmpty() {
286                    return sct.isEmpty();
287            }
288    
289            @Override
290            public Set keySet() {
291                    return sct.keySet();
292            }
293    
294            @Override
295            public Object put(Object key, Object value) {
296                    return sct.put(key, value);
297            }
298    
299            @Override
300            public void putAll(Map m) {
301                    sct.putAll(m);
302            }
303    
304            @Override
305            public Object remove(Object key) {
306                    return sct.remove(key);
307            }
308    
309            
310            @Override
311            public java.util.Collection values() {
312                    return sct.values();
313            }
314    
315            @Override
316            public Object append(Object o) throws PageException {
317                    throw new CasterException(sct,"Array");
318            }
319    
320            @Override
321            public Object appendEL(Object o) {
322                    throw new PageRuntimeException(new CasterException(sct,"Array"));
323            }
324    
325            @Override
326            public boolean containsKey(int key) {
327                    return sct.containsKey(ArgumentIntKey.init(key));
328            }
329    
330            @Override
331            public Object get(int key, Object defaultValue) {
332                    return sct.get(ArgumentIntKey.init(key),defaultValue);
333            }
334    
335            @Override
336            public int getDimension() {
337                    throw new PageRuntimeException(new CasterException(sct,"Array"));
338            }
339    
340            @Override
341            public Object getE(int key) throws PageException {
342                    return sct.get(KeyImpl.init(Caster.toString(key)));
343            }
344    
345            @Override
346            public boolean insert(int key, Object value) throws PageException {
347                    throw new CasterException(sct,"Array");
348            }
349    
350            @Override
351            public int[] intKeys() {
352                    throw new PageRuntimeException(new CasterException(sct,"Array"));
353            }
354    
355            @Override
356            public Object prepend(Object o) throws PageException {
357                    throw new CasterException(sct,"Array");
358            }
359    
360            @Override
361            public Object removeE(int key) throws PageException {
362                    return sct.remove(KeyImpl.init(Caster.toString(key)));
363            }
364    
365            @Override
366            public Object removeEL(int key) {
367                    return sct.removeEL(KeyImpl.init(Caster.toString(key)));
368            }
369    
370            @Override
371            public void resize(int to) throws PageException {
372                    throw new CasterException(sct,"Array");
373            }
374    
375            /**
376             * @param key
377             * @param value
378             * @return
379             * @throws PageException
380             */
381            public Object setE(int key, Object value) throws PageException {
382                    return sct.set(Caster.toString(key), value);
383            }
384    
385            @Override
386            public Object setEL(int key, Object value) {
387                    return sct.setEL(Caster.toString(key), value);
388            }
389    
390            @Override
391            public void sort(String sortType, String sortOrder) throws PageException {
392                    throw new CasterException(sct,"Array");
393            }
394    
395            public void sort(Comparator com) throws ExpressionException {
396                    throw new CasterException(sct,"Array");
397            }
398    
399            @Override
400            public Object[] toArray() {
401                    try {
402                            return Caster.toArray(sct).toArray();
403                    } catch (PageException pe) {
404                            throw new PageRuntimeException(pe);
405                    }
406            }
407    
408            @Override
409            public List toList() {
410                    try {
411                            return Caster.toArray(sct).toList();
412                    } catch (PageException pe) {
413                            throw new PageRuntimeException(pe);
414                    }
415            }
416            
417            @Override
418            public Object clone(){
419                    return duplicate(true);
420            }
421    
422            @Override
423            public long sizeOf() {
424                    return StructUtil.sizeOf(this);
425            }
426    
427            @Override
428            public Object get(PageContext pc, Key key, Object defaultValue) {
429                    return get(key, defaultValue);
430            }
431    
432            @Override
433            public Object get(PageContext pc, Key key) throws PageException {
434                    return get(key);
435            }
436    
437            @Override
438            public Object set(PageContext pc, Key propertyName, Object value) throws PageException {
439                    return set(propertyName, value);
440            }
441    
442            @Override
443            public Object setEL(PageContext pc, Key propertyName, Object value) {
444                    return setEL(propertyName, value);
445            }
446    
447            @Override
448            public Object call(PageContext pc, Key methodName, Object[] args) throws PageException {
449                    return MemberUtil.call(pc, this, methodName, args, CFTypes.TYPE_ARRAY, "array");
450            }
451    
452            @Override
453            public Object callWithNamedValues(PageContext pc, Key methodName, Struct args) throws PageException {
454                    return MemberUtil.callWithNamedValues(pc,this,methodName,args, CFTypes.TYPE_ARRAY, "array");
455            }
456            
457            @Override
458            public java.util.Iterator<String> getIterator() {
459            return keysAsStringIterator();
460        } 
461    
462    }