001    package railo.runtime.type;
002    
003    import java.util.Date;
004    import java.util.Iterator;
005    
006    import railo.runtime.PageContext;
007    import railo.runtime.dump.DumpData;
008    import railo.runtime.dump.DumpProperties;
009    import railo.runtime.exp.PageException;
010    import railo.runtime.op.Caster;
011    import railo.runtime.op.Duplicator;
012    import railo.runtime.op.Operator;
013    import railo.runtime.op.ThreadLocalDuplication;
014    import railo.runtime.op.date.DateCaster;
015    import railo.runtime.type.dt.DateTime;
016    import railo.runtime.type.it.EntryIterator;
017    import railo.runtime.type.ref.Reference;
018    import railo.runtime.type.util.StructSupport;
019    
020    public final class SVStruct extends StructSupport implements Reference,Struct {
021    
022        private Collection.Key key;
023        private StructImpl parent=new StructImpl();
024    
025        /**
026         * constructor of the class
027         * @param key
028         */
029        public SVStruct(Collection.Key key) {
030            this.key=key;
031        }
032        
033        @Override
034        public Collection.Key getKey() {
035            return key;
036        }
037    
038        @Override
039        public String getKeyAsString() {
040            return key.getString();
041        }
042    
043        @Override
044        public Object get(PageContext pc) throws PageException {
045            return get(key);
046        }
047    
048        @Override
049        public Object get(PageContext pc, Object defaultValue) {
050            return get(key,defaultValue);
051        }
052    
053        @Override
054        public Object set(PageContext pc, Object value) throws PageException {
055            return set(key,value);
056        }
057    
058        @Override
059        public Object setEL(PageContext pc, Object value) {
060            return setEL(key,value);
061        }
062    
063        @Override
064        public Object remove(PageContext pc) throws PageException {
065            return remove(key);
066        }
067        
068        @Override
069        public Object removeEL(PageContext pc) {
070            return removeEL(key);
071        }
072    
073        @Override
074        public Object touch(PageContext pc) throws PageException {
075            Object o=get(key,null);
076            if(o!=null) return o;
077            return set(key,new StructImpl());
078        }
079        
080        @Override
081        public Object touchEL(PageContext pc) {
082            Object o=get(key,null);
083            if(o!=null) return o;
084            return setEL(key,new StructImpl());
085        }
086    
087        public Object getParent() {
088            return parent;
089        }
090    
091        @Override
092        public void clear() {
093            parent.clear();
094        }
095    
096        @Override
097            public Iterator<Collection.Key> keyIterator() {
098            return parent.keyIterator();
099        }
100        
101            @Override
102            public Iterator<String> keysAsStringIterator() {
103            return parent.keysAsStringIterator();
104        }
105            
106            @Override
107            public Iterator<Entry<Key, Object>> entryIterator() {
108                    return new EntryIterator(this, keys());
109            }
110            
111            @Override
112            public Iterator<Object> valueIterator() {
113                    return parent.valueIterator();
114            }
115    
116        @Override
117        public Collection.Key[] keys() {
118            return parent.keys();
119        }
120    
121        @Override
122        public int size() {
123            return parent.size();
124        }
125    
126        @Override
127            public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) {
128                return parent.toDumpData(pageContext,maxlevel,dp);
129        }
130    
131        @Override
132        public boolean castToBooleanValue() throws PageException {
133            return Caster.toBooleanValue(get(key));
134        }
135        
136        @Override
137        public Boolean castToBoolean(Boolean defaultValue) {
138            Object value = get(key,defaultValue); 
139            if(value==null)return defaultValue;
140            return Caster.toBoolean(value,defaultValue);
141        }
142    
143        @Override
144        public DateTime castToDateTime() throws PageException {
145            return Caster.toDate(get(key),null);
146        }
147        
148        @Override
149        public DateTime castToDateTime(DateTime defaultValue) {
150            Object value = get(key,defaultValue);
151            if(value==null)return defaultValue;
152            return DateCaster.toDateAdvanced(value, true, null, defaultValue); 
153        }
154    
155        @Override
156        public double castToDoubleValue() throws PageException {
157            return Caster.toDoubleValue(get(key));
158        }
159        
160        @Override
161        public double castToDoubleValue(double defaultValue) {
162            Object value=get(key,null);
163            if(value==null)return defaultValue;
164            return Caster.toDoubleValue(value,defaultValue);
165        }
166    
167        @Override
168        public String castToString() throws PageException {
169            return Caster.toString(get(key));
170        }
171        
172            @Override
173            public String castToString(String defaultValue) {
174                    Object value = get(key,null);
175                    if(value==null) return defaultValue;
176                    
177                    return Caster.toString(value,defaultValue);
178            }
179    
180    
181            @Override
182            public int compareTo(boolean b) throws PageException {
183                    return Operator.compare(castToBooleanValue(), b);
184            }
185    
186            @Override
187            public int compareTo(DateTime dt) throws PageException {
188                    return Operator.compare((Date)castToDateTime(), (Date)dt);
189            }
190    
191            @Override
192            public int compareTo(double d) throws PageException {
193                    return Operator.compare(castToDoubleValue(), d);
194            }
195    
196            @Override
197            public int compareTo(String str) throws PageException {
198                    return Operator.compare(castToString(), str);
199            }
200    
201        @Override
202        public Collection duplicate(boolean deepCopy) {
203            SVStruct svs = new SVStruct(key);
204            ThreadLocalDuplication.set(this, svs);
205            try{
206                    Collection.Key[] keys = keys();
207                    for(int i=0;i<keys.length;i++) {
208                        if(deepCopy)svs.setEL(keys[i],Duplicator.duplicate(get(keys[i],null),deepCopy));
209                        else svs.setEL(keys[i],get(keys[i],null));
210                    }
211                    return svs;
212            }
213            finally{
214                    // ThreadLocalDuplication.remove(this); removed "remove" to catch sisters and brothers
215            }
216        }
217    
218            
219            
220        
221    
222            @Override
223            public boolean containsKey(Collection.Key key) {
224                    return parent.containsKey(key);
225            }
226            
227    
228            @Override
229            public Object get(Collection.Key key) throws PageException {
230                    return parent.get(key);
231            }
232    
233            @Override
234            public Object get(Collection.Key key, Object defaultValue) {
235                    return parent.get(key, defaultValue);
236            }
237    
238    
239            @Override
240            public Object remove(Collection.Key key) throws PageException {
241                    return parent.remove(key);
242            }
243    
244            @Override
245            public Object removeEL(Collection.Key key) {
246                    return parent.removeEL(key);
247            }
248    
249            @Override
250            public Object set(Collection.Key key, Object value) throws PageException {
251                    return parent.set(key, value);
252            }
253    
254            @Override
255            public Object setEL(Collection.Key key, Object value) {
256                    return parent.setEL(key, value);
257            }
258    
259            @Override
260            public boolean containsValue(Object value) {
261                    return parent.containsValue(value);
262            }
263    
264            @Override
265            public java.util.Collection values() {
266                    return parent.values();
267            }
268    
269    }