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    }