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}