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