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