001    package ca.uhn.hl7v2.conf.spec.message;
002    
003    import ca.uhn.hl7v2.conf.ProfileException;
004    
005    /**
006     * An abstraction of the common features of Field, Component, and SubComponent.  
007     * @author Bryan Tripp
008     */
009    public class AbstractComponent {
010        
011        /** Creates a new instance of AbstractComponent */
012        public AbstractComponent() {
013            dataValues = new DataValue[0];
014        }
015        
016        
017        /** Utility field used by bound properties. */
018        protected java.beans.PropertyChangeSupport propertyChangeSupport =  new java.beans.PropertyChangeSupport(this);
019        
020        /** Utility field used by constrained properties. */
021        protected java.beans.VetoableChangeSupport vetoableChangeSupport =  new java.beans.VetoableChangeSupport(this);
022        
023        private String impNote;
024        private String description;
025        private String reference;
026        private String predicate;
027        private DataValue[] dataValues;
028        private String name;
029        private String usage;
030        private String datatype;
031        private long length;
032        private String constantValue;
033        private String table;
034        
035        /** Adds a PropertyChangeListener to the listener list.
036         * @param l The listener to add.
037         */
038        public void addPropertyChangeListener(java.beans.PropertyChangeListener l) {
039            propertyChangeSupport.addPropertyChangeListener(l);
040        }
041        
042        /** Removes a PropertyChangeListener from the listener list.
043         * @param l The listener to remove.
044         */
045        public void removePropertyChangeListener(java.beans.PropertyChangeListener l) {
046            propertyChangeSupport.removePropertyChangeListener(l);
047        }
048        
049        /** Adds a VetoableChangeListener to the listener list.
050         * @param l The listener to add.
051         */
052        public void addVetoableChangeListener(java.beans.VetoableChangeListener l) {
053            vetoableChangeSupport.addVetoableChangeListener(l);
054        }
055        
056        /** Removes a VetoableChangeListener from the listener list.
057         * @param l The listener to remove.
058         */
059        public void removeVetoableChangeListener(java.beans.VetoableChangeListener l) {
060            vetoableChangeSupport.removeVetoableChangeListener(l);
061        }
062        
063        /** Getter for property impNote.
064         * @return Value of property impNote.
065         */
066        public String getImpNote() {
067            return this.impNote;
068        }
069        
070        /** Setter for property impNote.
071         * @param impNote New value of property impNote.
072         *
073         * @throws ProfileException
074         */
075        public void setImpNote(String impNote) throws ProfileException {
076            String oldImpNote = this.impNote;
077            try {
078                vetoableChangeSupport.fireVetoableChange("impNote", oldImpNote, impNote);
079            } catch (Exception e) {
080                throw new ProfileException(null, e);
081            }
082            this.impNote = impNote;
083            propertyChangeSupport.firePropertyChange("impNote", oldImpNote, impNote);
084        }
085        
086        /** Getter for property description.
087         * @return Value of property description.
088         */
089        public String getDescription() {
090            return this.description;
091        }
092        
093        /** Setter for property description.
094         * @param description New value of property description.
095         *
096         * @throws ProfileException
097         */
098        public void setDescription(String description) throws ProfileException {
099            String oldDescription = this.description;
100            try {
101                vetoableChangeSupport.fireVetoableChange("description", oldDescription, description);
102            } catch (Exception e) {
103                throw new ProfileException(null, e);
104            }
105            this.description = description;
106            propertyChangeSupport.firePropertyChange("description", oldDescription, description);
107        }
108        
109        /** Getter for property reference.
110         * @return Value of property reference.
111         */
112        public String getReference() {
113            return this.reference;
114        }
115        
116        /** Setter for property reference.
117         * @param reference New value of property reference.
118         *
119         * @throws ProfileException
120         */
121        public void setReference(String reference) throws ProfileException {
122            String oldReference = this.reference;
123            try {
124                vetoableChangeSupport.fireVetoableChange("reference", oldReference, reference);
125            } catch (Exception e) {
126                throw new ProfileException(null, e);
127            }
128            this.reference = reference;
129            propertyChangeSupport.firePropertyChange("reference", oldReference, reference);
130        }
131        
132        /** Getter for property predicate.
133         * @return Value of property predicate.
134         */
135        public String getPredicate() {
136            return this.predicate;
137        }
138        
139        /** Setter for property predicate.
140         * @param predicate New value of property predicate.
141         *
142         * @throws ProfileException
143         */
144        public void setPredicate(String predicate) throws ProfileException {
145            String oldPredicate = this.predicate;
146            try {
147                vetoableChangeSupport.fireVetoableChange("predicate", oldPredicate, predicate);
148            } catch (Exception e) {
149                throw new ProfileException(null, e);
150            }
151            this.predicate = predicate;
152            propertyChangeSupport.firePropertyChange("predicate", oldPredicate, predicate);
153        }
154        
155        /** Indexed getter for property dataValues.
156         * @param index Index of the property.
157         * @return Value of the property at <CODE>index</CODE>.
158         */
159        public DataValue getDataValues(int index) {
160            return this.dataValues[index];
161        }
162        
163        /** Indexed setter for property dataValues.
164         * @param index Index of the property.
165         * @param dataValues New value of the property at <CODE>index</CODE>.
166         *
167         * @throws ProfileException
168         */
169        public void setDataValues(int index, DataValue dataValue) throws ProfileException {
170            extendDataValuesList(index);
171            DataValue oldDataValues = this.dataValues[index];
172            this.dataValues[index] = dataValue;
173            try {
174                vetoableChangeSupport.fireVetoableChange("dataValues", null, null );
175            }
176            catch(java.beans.PropertyVetoException vetoException ) {
177                this.dataValues[index] = oldDataValues;
178                throw new ProfileException(null, vetoException);
179            }
180            propertyChangeSupport.firePropertyChange("dataValues", null, null );
181        }
182        
183        /** Makes data value list long enough to accommodate setter.  */
184        private void extendDataValuesList(int index) {
185            if (index >= this.dataValues.length) {
186                DataValue[] newCopy = new DataValue[index + 1];
187                System.arraycopy(this.dataValues, 0, newCopy, 0, this.dataValues.length);
188                this.dataValues = newCopy;
189            }        
190        }
191        
192        
193        
194        /** Getter for property name.
195         * @return Value of property name.
196         */
197        public String getName() {
198            return this.name;
199        }
200        
201        /** Setter for property name.
202         * @param name New value of property name.
203         *
204         * @throws ProfileException
205         */
206        public void setName(String name) throws ProfileException {
207            String oldName = this.name;
208            try {
209                vetoableChangeSupport.fireVetoableChange("name", oldName, name);
210            } catch (Exception e) {
211                throw new ProfileException(null, e);
212            }
213            this.name = name;
214            propertyChangeSupport.firePropertyChange("name", oldName, name);
215        }
216        
217        /** Getter for property usage.
218         * @return Value of property usage.
219         */
220        public String getUsage() {
221            return this.usage;
222        }
223        
224        /** Setter for property usage.
225         * @param usage New value of property usage.
226         *
227         * @throws ProfileException
228         */
229        public void setUsage(String usage) throws ProfileException {
230            String oldUsage = this.usage;
231            try {
232                vetoableChangeSupport.fireVetoableChange("usage", oldUsage, usage);
233            } catch (Exception e) {
234                throw new ProfileException(null, e);
235            }
236            this.usage = usage;
237            propertyChangeSupport.firePropertyChange("usage", oldUsage, usage);
238        }
239        
240        /** Getter for property datatype.
241         * @return Value of property datatype.
242         */
243        public String getDatatype() {
244            return this.datatype;
245        }
246        
247        /** Setter for property datatype.
248         * @param datatype New value of property datatype.
249         *
250         * @throws ProfileException
251         */
252        public void setDatatype(String datatype) throws ProfileException {
253            String oldDatatype = this.datatype;
254            try {
255                vetoableChangeSupport.fireVetoableChange("datatype", oldDatatype, datatype);
256            } catch (Exception e) {
257                throw new ProfileException(null, e);
258            }
259            this.datatype = datatype;
260            propertyChangeSupport.firePropertyChange("datatype", oldDatatype, datatype);
261        }
262        
263        /** Getter for property length.
264         * @return Value of property length.
265         */
266        public long getLength() {
267            return this.length;
268        }
269        
270        /** Setter for property length.
271         * @param length New value of property length.
272         *
273         * @throws ProfileException
274         */
275        public void setLength(long length) throws ProfileException {
276            long oldLength = this.length;
277            try {
278                vetoableChangeSupport.fireVetoableChange("length", new Long(oldLength), new Long(length));
279            } catch (Exception e) {
280                throw new ProfileException(null, e);
281            }
282            this.length = length;
283            propertyChangeSupport.firePropertyChange("length", new Long(oldLength), new Long(length));
284        }
285        
286        /** Getter for property constantValue.
287         * @return Value of property constantValue.
288         */
289        public String getConstantValue() {
290            return this.constantValue;
291        }
292        
293        /** Setter for property constantValue.
294         * @param constantValue New value of property constantValue.
295         *
296         * @throws ProfileException
297         */
298        public void setConstantValue(String constantValue) throws ProfileException {
299            String oldConstantValue = this.constantValue;
300            try {
301                vetoableChangeSupport.fireVetoableChange("constantValue", oldConstantValue, constantValue);
302            } catch (Exception e) {
303                throw new ProfileException(null, e);
304            }
305            this.constantValue = constantValue;
306            propertyChangeSupport.firePropertyChange("constantValue", oldConstantValue, constantValue);
307        }
308        
309        /** Getter for property table.
310         * @return Value of property table.
311         */
312        public String getTable() {
313            return this.table;
314        }
315        
316        /** Setter for property table.
317         * @param table New value of property table.
318         *
319         * @throws ProfileException
320         */
321        public void setTable(String table) throws ProfileException {
322            String oldTable = this.table;
323            try {
324                vetoableChangeSupport.fireVetoableChange("table", oldTable, table);
325            } catch (Exception e) {
326                throw new ProfileException(null, e);
327            }
328            this.table = table;
329            propertyChangeSupport.firePropertyChange("table", oldTable, table);
330        }
331        
332    }