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 **/ 019/** 020 * 021 */ 022package lucee.runtime; 023 024import java.util.Iterator; 025import java.util.Map; 026import java.util.Set; 027 028import lucee.commons.lang.types.RefBoolean; 029import lucee.runtime.component.DataMember; 030import lucee.runtime.component.Member; 031import lucee.runtime.component.MemberSupport; 032import lucee.runtime.component.Property; 033import lucee.runtime.dump.DumpData; 034import lucee.runtime.dump.DumpProperties; 035import lucee.runtime.exp.PageException; 036import lucee.runtime.op.Duplicator; 037import lucee.runtime.type.Collection; 038import lucee.runtime.type.KeyImpl; 039import lucee.runtime.type.Sizeable; 040import lucee.runtime.type.Struct; 041import lucee.runtime.type.StructImpl; 042import lucee.runtime.type.UDF; 043import lucee.runtime.type.UDFProperties; 044import lucee.runtime.type.dt.DateTime; 045import lucee.runtime.type.util.StructUtil; 046 047/** 048 * 049 */ 050public class SuperComponent extends MemberSupport implements ComponentPro, Member,Sizeable { 051 052 private ComponentImpl comp; 053 054 private SuperComponent(ComponentImpl comp) { 055 super(Component.ACCESS_PRIVATE); 056 this.comp=comp; 057 } 058 059 060 public static Member superMember(ComponentImpl comp) { 061 if(comp==null) return new DataMember(Component.ACCESS_PRIVATE,new StructImpl()); 062 return new SuperComponent(comp); 063 } 064 public static Collection superInstance(ComponentImpl comp) { 065 if(comp==null) return new StructImpl(); 066 return new SuperComponent(comp); 067 } 068 069 @Override 070 public Object getValue() { 071 return this; 072 } 073 @Override 074 public Object call(PageContext pc, String name, Object[] args) throws PageException { 075 return comp._call(pc, getAccess(), KeyImpl.init(name), null, args,true); 076 } 077 078 @Override 079 public Object call(PageContext pc, Key name, Object[] args) throws PageException { 080 return comp._call(pc, getAccess(), name, null, args,true); 081 } 082 083 @Override 084 public Object callWithNamedValues(PageContext pc, String name, Struct args) throws PageException { 085 return comp._call(pc, getAccess(), KeyImpl.init(name), args,null,true); 086 } 087 088 @Override 089 public Object callWithNamedValues(PageContext pc, Key methodName, Struct args) throws PageException { 090 return comp._call(pc, getAccess(), methodName, args,null,true); 091 } 092 093 @Override 094 public boolean castToBooleanValue() throws PageException { 095 return comp.castToBooleanValue(true); 096 } 097 098 @Override 099 public Boolean castToBoolean(Boolean defaultValue) { 100 return comp.castToBoolean(true,defaultValue); 101 } 102 103 @Override 104 public DateTime castToDateTime() throws PageException { 105 return comp.castToDateTime(true); 106 } 107 108 @Override 109 public DateTime castToDateTime(DateTime defaultValue) { 110 return comp.castToDateTime(true,defaultValue); 111 } 112 113 @Override 114 public double castToDoubleValue() throws PageException { 115 return comp.castToDoubleValue(true); 116 } 117 118 @Override 119 public double castToDoubleValue(double defaultValue) { 120 return comp.castToDoubleValue(true,defaultValue); 121 } 122 123 @Override 124 public String castToString() throws PageException { 125 return comp.castToString(true); 126 } 127 128 @Override 129 public String castToString(String defaultValue) { 130 return comp.castToString(true,defaultValue); 131 } 132 133 @Override 134 public void clear() { 135 comp.clear(); 136 } 137 138 @Override 139 public Object clone() { 140 return duplicate(true); 141 } 142 143 @Override 144 public int compareTo(boolean b) throws PageException { 145 return comp.compareTo(b); 146 } 147 148 @Override 149 public int compareTo(DateTime dt) throws PageException { 150 return comp.compareTo(dt); 151 } 152 153 @Override 154 public int compareTo(double d) throws PageException { 155 return comp.compareTo(d); 156 } 157 158 @Override 159 public int compareTo(String str) throws PageException { 160 return comp.compareTo(str); 161 } 162 163 @Override 164 public boolean containsKey(String name) { 165 return comp.contains(getAccess(),(name)); 166 } 167 168 @Override 169 public boolean containsKey(Key key) { 170 return comp.contains(getAccess(),key.getLowerString()); 171 } 172 173 @Override 174 public synchronized Collection duplicate(boolean deepCopy) { 175 return new SuperComponent((ComponentImpl) Duplicator.duplicate(comp,deepCopy)); 176 } 177 178 @Override 179 public Object get(PageContext pc, Key key) throws PageException { 180 return get(key); 181 } 182 183 @Override 184 public Object get(PageContext pc, Key key, Object defaultValue) { 185 return get(key, defaultValue); 186 } 187 188 @Override 189 public Object get(String name) throws PageException { 190 return get(KeyImpl.init(name)); 191 } 192 193 @Override 194 public Object get(String name, Object defaultValue) { 195 return get(KeyImpl.init(name), defaultValue); 196 } 197 198 @Override 199 public Object get(Key key) throws PageException { 200 Member member=comp.getMember(getAccess(),key,true,true); 201 if(member!=null) return member.getValue(); 202 return comp.get(getAccess(), key); 203 } 204 205 @Override 206 public Object get(Key key, Object defaultValue) { 207 Member member=comp.getMember(getAccess(),key,true,true); 208 if(member!=null) return member.getValue(); 209 return comp.get(getAccess(), key, defaultValue); 210 } 211 212 @Override 213 public String getAbsName() { 214 return comp.getAbsName(); 215 } 216 217 @Override 218 public String getBaseAbsName() { 219 return comp.getBaseAbsName(); 220 } 221 222 public boolean isBasePeristent() { 223 return comp.isPersistent(); 224 } 225 226 @Override 227 public String getCallName() { 228 return comp.getCallName(); 229 } 230 231 @Override 232 public String getDisplayName() { 233 return comp.getDisplayName(); 234 } 235 236 @Override 237 public String getExtends() { 238 return comp.getExtends(); 239 } 240 241 @Override 242 public String getHint() { 243 return comp.getHint(); 244 } 245 246 @Override 247 public Class getJavaAccessClass(RefBoolean isNew) throws PageException { 248 return comp.getJavaAccessClass(isNew); 249 } 250 251 @Override 252 public synchronized Struct getMetaData(PageContext pc) throws PageException { 253 return comp.getMetaData(pc); 254 } 255 256 @Override 257 public String getName() { 258 return comp.getName(); 259 } 260 261 @Override 262 public boolean getOutput() { 263 return comp.getOutput(); 264 } 265 266 @Override 267 public boolean instanceOf(String type) { 268 return comp.top.instanceOf(type); 269 } 270 271 public boolean isInitalized() { 272 return comp.top.isInitalized(); 273 } 274 275 @Override 276 public boolean isValidAccess(int access) { 277 return comp.isValidAccess(access); 278 } 279 280 @Override 281 public Iterator<Collection.Key> keyIterator() { 282 return comp.keyIterator(getAccess()); 283 } 284 285 @Override 286 public Iterator<String> keysAsStringIterator() { 287 return comp.keysAsStringIterator(getAccess()); 288 } 289 290 @Override 291 public Iterator<Entry<Key, Object>> entryIterator() { 292 return comp.entryIterator(getAccess()); 293 } 294 295 @Override 296 public Key[] keys() { 297 return comp.keys(getAccess()); 298 } 299 300 @Override 301 public Object remove(Key key) throws PageException { 302 return comp.remove(key); 303 } 304 305 306 @Override 307 public Object removeEL(Key key) { 308 return comp.removeEL(key); 309 } 310 311 @Override 312 public Object set(PageContext pc, Key key, Object value) throws PageException { 313 return comp.set(pc, key, value); 314 } 315 316 @Override 317 public Object set(String name, Object value) throws PageException { 318 return comp.set(name, value); 319 } 320 321 @Override 322 public Object set(Key key, Object value) throws PageException { 323 return comp.set(key, value); 324 } 325 326 @Override 327 public Object setEL(PageContext pc, Key name, Object value) { 328 return comp.setEL(pc, name, value); 329 } 330 331 @Override 332 public Object setEL(String name, Object value) { 333 return comp.setEL(name, value); 334 } 335 336 @Override 337 public Object setEL(Key key, Object value) { 338 return comp.setEL(key, value); 339 } 340 341 @Override 342 public int size() { 343 return comp.size(getAccess()); 344 } 345 346 @Override 347 public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) { 348 return comp.top.toDumpData(pageContext, maxlevel,dp); 349 } 350 351 @Override 352 public PageSource getPageSource() { 353 return comp.getPageSource(); 354 } 355 356 357 @Override 358 public boolean containsKey(Object key) { 359 return containsKey(KeyImpl.toKey(key,null)); 360 } 361 362 363 @Override 364 public Set entrySet() { 365 return StructUtil.entrySet(this); 366 } 367 368 369 @Override 370 public Object get(Object key) { 371 return get(KeyImpl.toKey(key,null), null); 372 } 373 374 375 @Override 376 public boolean isEmpty() { 377 return size()==0; 378 } 379 380 @Override 381 public Set keySet() { 382 return StructUtil.keySet(this); 383 } 384 385 386 @Override 387 public Object put(Object key, Object value) { 388 return setEL(KeyImpl.toKey(key,null), value); 389 } 390 391 @Override 392 public void putAll(Map map) { 393 StructUtil.putAll(this, map); 394 } 395 396 @Override 397 public Object remove(Object key) { 398 return removeEL(KeyImpl.toKey(key,null)); 399 } 400 401 @Override 402 public java.util.Collection values() { 403 return StructUtil.values(this); 404 } 405 406 @Override 407 public boolean containsValue(Object value) { 408 return values().contains(value); 409 } 410 411 412 public Iterator<Object> valueIterator() { 413 return comp.valueIterator(); 414 } 415 416 @Override 417 public Property[] getProperties(boolean onlyPeristent) { 418 return comp.getProperties(onlyPeristent); 419 } 420 421 @Override 422 public Property[] getProperties(boolean onlyPeristent, boolean includeBaseProperties, boolean overrideProperties, boolean inheritedMappedSuperClassOnly) { 423 return comp.getProperties(onlyPeristent,includeBaseProperties, overrideProperties, inheritedMappedSuperClassOnly); 424 } 425 426 427 @Override 428 public ComponentScope getComponentScope() { 429 return comp.getComponentScope(); 430 } 431 432 @Override 433 public boolean contains(PageContext pc, Key key) { 434 return comp.contains(getAccess(),key); 435 } 436 437 /*private Member getMember(int access, Key key, boolean dataMember,boolean superAccess) { 438 return comp.getMember(access, key, dataMember, superAccess); 439 }*/ 440 441 @Override 442 public void setProperty(Property property) throws PageException { 443 comp.setProperty(property); 444 } 445 446 447 @Override 448 public long sizeOf() { 449 return StructUtil.sizeOf(this); 450 } 451 452 453 public boolean equalTo(String type) { 454 return comp.top.equalTo(type); 455 } 456 457 @Override 458 public String getWSDLFile() { 459 return comp.getWSDLFile(); 460 } 461 462 @Override 463 public void registerUDF(String key, UDF udf){ 464 comp.registerUDF(key, udf); 465 } 466 467 @Override 468 public void registerUDF(Collection.Key key, UDF udf){ 469 comp.registerUDF(key, udf); 470 } 471 472 @Override 473 public void registerUDF(String key, UDFProperties props){ 474 comp.registerUDF(key, props); 475 } 476 477 @Override 478 public void registerUDF(Collection.Key key, UDFProperties props){ 479 comp.registerUDF(key, props); 480 } 481 482 @Override 483 public java.util.Iterator<String> getIterator() { 484 return keysAsStringIterator(); 485 } 486 487 @Override 488 public boolean isPersistent() { 489 return comp.isPersistent(); 490 } 491 492 @Override 493 public boolean isAccessors() { 494 return comp.isAccessors(); 495 } 496 497 @Override 498 public void setEntity(boolean entity) { 499 comp.setEntity(entity); 500 } 501 502 @Override 503 public boolean isEntity() { 504 return comp.isEntity(); 505 } 506 507 @Override 508 public Component getBaseComponent() { 509 return comp.getBaseComponent(); 510 } 511 512 513 @Override 514 public Set<Key> keySet(int access) { 515 return comp.keySet(access); 516 } 517 518 @Override 519 public Object getMetaStructItem(Key name) { 520 return comp.getMetaStructItem(name); 521 } 522 523 524 @Override 525 public Object call(PageContext pc, int access, Key name, Object[] args) throws PageException { 526 return comp.call(pc, access, name, args); 527 } 528 529 530 @Override 531 public Object callWithNamedValues(PageContext pc, int access, Key name, Struct args) throws PageException { 532 return comp.callWithNamedValues(pc, access, name, args); 533 } 534 535 @Override 536 public int size(int access) { 537 return comp.size(); 538 } 539 540 @Override 541 public Key[] keys(int access) { 542 return comp.keys(access); 543 } 544 545 546 @Override 547 public Iterator<Key> keyIterator(int access) { 548 return comp.keyIterator(access); 549 } 550 551 @Override 552 public Iterator<String> keysAsStringIterator(int access) { 553 return comp.keysAsStringIterator(access); 554 } 555 556 @Override 557 public Iterator<Entry<Key, Object>> entryIterator(int access) { 558 return comp.entryIterator(access); 559 } 560 561 @Override 562 public Iterator<Object> valueIterator(int access) { 563 return comp.valueIterator(access); 564 } 565 566 @Override 567 public Object get(int access, Key key) throws PageException { 568 return comp.get(access, key); 569 } 570 571 @Override 572 public Object get(int access, Key key, Object defaultValue) { 573 return comp.get(access, key, defaultValue); 574 } 575 576 @Override 577 public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp, int access) { 578 return toDumpData(pageContext, maxlevel, dp, access); 579 } 580 581 @Override 582 public boolean contains(int access, Key name) { 583 return comp.contains(access, name); 584 } 585 586 @Override 587 public Member getMember(int access, Key key, boolean dataMember, boolean superAccess) { 588 return comp.getMember(access, key, dataMember, superAccess); 589 } 590}