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 }