linuxsampler/lscp/AbstractParameter.java

/*
 *   jlscp - a java LinuxSampler control protocol API
 *
 *   Copyright (C) 2005-2006 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of jlscp.
 *
 *   jlscp is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   jlscp is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with jlscp; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.linuxsampler.lscp;

/**
 * This class provides default implementation of the <code>Parameter</code> interface.
 *
 * @author  Grigor Iliev
 */
public abstract class AbstractParameter<T> implements Parameter<T>, Parseable {
        private String name = null;
        private ParameterType type = null;
        private String desc = null;
        private boolean fix = true;
        private boolean multiplicity = true;
        
        private boolean mandatory = false;
        private String[] depends = null;
        
        private T val = null;
        private T dflt = null;
        private Number rangeMin = null;
        private Number rangeMax = null;
        private T[] possibilities = null;
        
        
        public
        AbstractParameter() {
                
        }

        /**
         * Gets the name of this parameter.
         * @return The name of this parameter.
         */
        public String
        getName() { return name; }
        
        /**
         * Sets the name of this parameter.
         * @param name A <code>String</code> object containing the new name for this parameter.
         */
        public void
        setName(String name) { this.name = name; }
        
        /**
         * Gets the description of this parameter.
         * @return The description of this parameter.
         */
        public String
        getDescription() { return desc; }
        
        /**
         * Sets the description of this parameter.
         * @param desc A <code>String</code> instance containing the description of this parameter.
         */
        public void
        setDescription(String desc) { this.desc = desc; }
        
        /**
         * Gets the type of this parameter.
         * @return The type of this parameter.
         */
        public ParameterType
        getType() { return type; }
        
        /**
         * Sets the type of this parameter.
         * @param type The type of this parameter.
         */
        public void
        setType(ParameterType type) { this.type = type; }
        
        /**
         * Gets the current value of this parameter.
         * @return The current value of this parameter.
         */
        public T
        getValue() { return val; }
        
        /**
         * Sets the current value of this parameter.
         * @param val The new value for this parameter.
         */
        public void
        setValue(T val) { this.val = val; }
        
        /**
         * Determines whether this parameter contains boolean value.
         * @return <code>true</code> if this parameter contains boolean value,
         * <code>false</code> otherwise.
         */
        public boolean
        isBoolean() { return type == ParameterType.BOOL; }
        
        /**
         * Determines whether this parameter contains integer value.
         * @return <code>true</code> if this parameter contains integer value,
         * <code>false</code> otherwise.
         */
        public boolean
        isInteger() { return type == ParameterType.INT; }
        
        /**
         * Determines whether this parameter contains float value.
         * @return <code>true</code> if this parameter contains float value,
         * <code>false</code> otherwise.
         */
        public boolean
        isFloat() { return type == ParameterType.FLOAT; }
        
        /**
         * Determines whether this parameter contains string value.
         * @return <code>true</code> if this parameter contains string value,
         * <code>false</code> otherwise.
         */
        public boolean
        isString() { return type == ParameterType.STRING; }
        
        /**
         * Determines whether this parameter contains list of boolean values.
         * @return <code>true</code> if this parameter contains list of boolean values,
         * <code>false</code> otherwise.
         */
        public boolean
        isBooleanList() { return type == ParameterType.BOOL_LIST; }
        
        /**
         * Determines whether this parameter contains list of integer values.
         * @return <code>true</code> if this parameter contains list of integer values,
         * <code>false</code> otherwise.
         */
        public boolean
        isIntegerList() { return type == ParameterType.INT_LIST; }
        
        /**
         * Determines whether this parameter contains list of float values.
         * @return <code>true</code> if this parameter contains list of float values,
         * <code>false</code> otherwise.
         */
        public boolean
        isFloatList() { return type == ParameterType.FLOAT_LIST; }
        
        /**
         * Determines whether this parameter contains list of string values.
         * @return <code>true</code> if this parameter contains list of string values,
         * <code>false</code> otherwise.
         */
        public boolean
        isStringList() { return type == ParameterType.STRING_LIST; }
        
        /**
         * Defines if this parameter can be altered.
         * @return <code>true</code> if the parameter is readonly and <code>false</code>
         * if the parameter can be altered.
         */
        public boolean
        isFixed() { return fix; }
        
        /**
         * Defines if this parameter allows only one value or list of values.
         * @return <code>false</code> if this parameter allows only one value and <code>true</code>
         * if allows a list of values.
         */
        public boolean
        isMultiplicity() { return multiplicity; }
        
        /**
         * Sets if this parameter allows only one value or list of values.
         * @param b <code>true</code> if this parameter allows list of values,
         * <code>false</code> otherwise.
         */
        public void
        setMultiplicity(boolean b) { multiplicity = b; }
        
        /**
         * Defines if this parameter must be given when the device is to be created.
         * @return <code>true</code> if this parameter must be given when the device 
         * is to be created and <code>false</code> otherwise.
         */
        public boolean
        isMandatory() { return mandatory; }
        
        /**
         * Gets a <code>String</code> array with parameter's names this parameter depends on.
         * @return A <code>String</code> array with parameter's names this parameter depends on
         * or <code>null</code> if this parameter has no dependances.
         */
        public String[]
        getDependances() { return depends; }
        
        /**
         * Checks if this parameter depends on some other parameter(s).
         * @return <code>true</code> if this parameter depends on some other parameter(s)
         * and <code>false</code> otherwise.
         */
        public boolean
        hasDependances() { return depends != null; }
        
        /**
         * Parses a line of text.
         * @param s A string to be parsed.
         * @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
         * @throws LscpException If some error occurs.
         */
        public boolean
        parse(String s) throws LscpException {
                if(s.startsWith("DESCRIPTION: ")) {
                        desc = s.substring("DESCRIPTION: ".length(), s.length());
                        return true;
                } else if(s.startsWith("FIX: ")) {
                        fix = Boolean.parseBoolean(s.substring("FIX: ".length(), s.length()));
                        return true;
                } else if(s.startsWith("MANDATORY: ")) {
                        mandatory = Boolean.parseBoolean (
                                s.substring("MANDATORY: ".length(), s.length())
                        );
                        return true;
                } else if(s.startsWith("DEPENDS: ")) {
                        s = s.substring("DEPENDS: ".length(), s.length());
                        depends = Parser.parseList(s);
                        return true;
                }else if(s.startsWith("TYPE: ")) {
                        
                        return true;
                }else if(s.startsWith("MULTIPLICITY: ")) {
                        
                        return true;
                }
                
                return false;
        }
        
        /**
         * Parses the specified lines.
         * @param lnS The lines to be parsed.
         * @throws LscpException If some error occurs.
         */
        protected void
        parseLines(String[] lnS) throws LscpException {
                for(String s : lnS) if(!parse(s)) {
                        Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
                }
        }
        
        /**
         * Gets the default value for this parameter.
         * @return The default value for this parameter.
         */
        public T
        getDefault() { return dflt; }
        
        /**
         * Sets the default value for this parameter.
         * @param dflt Specifies the default value for this parameter.
         */
        public T
        setDefault(T dflt) { return this.dflt = dflt; }
        
        /**
         * Gets the lower limit of the allowed value range for this parameter.
         * @return The lower limit of the allowed value range for this
         * parameter or <code>null</code> if the parameter doesn't have lower limit.
         */
        public Number
        getRangeMin() { return rangeMin; }
        
        /**
         * Sets the lower limit of the allowed value range for this parameter.
         * @param min Specifies the lower limit of the allowed value range for this parameter.
         */
        public void
        setRangeMin(Number min) { rangeMin = min; }
        
        /**
         * Gets the upper limit of the allowed value range for this parameter.
         * @return The upper limit of the allowed value range for this
         * parameter or <code>null</code> if the parameter doesn't have upper limit.
         */
        public Number
        getRangeMax() { return rangeMax; }
        
        /**
         * Sets the upper limit of the allowed value range for this parameter.
         * @param max Specifies the upper limit of the allowed value range for this parameter.
         */
        public void
        setRangeMax(Number max) { rangeMax = max; }
        
        /**
         * Gets a list of possible values for this parameter.
         * @return A list of possible values for this parameter.
         */
        public T[]
        getPossibilities() { return possibilities; }
                
        /**
         * Sets the list of possible values for this parameter.
         * @param pos The new list of possible values for this parameter.
         */
        public void
        setPossibilities(T[] pos) { possibilities = pos; }
                
        /**
         * Determines whether this parameter has a lower limit.
         * @return <code>true</code> if this parameter has a lower limit,
         * <code>false</code> otherwise.
         */
        public boolean
        hasRangeMin() { return rangeMin != null; }
        
        /**
         * Determines whether this parameter has an upper limit.
         * @return <code>true</code> if this parameter has an upper limit,
         * <code>false</code> otherwise.
         */
        public boolean
        hasRangeMax() { return rangeMax != null; }
        
        /**
         * Determines whether this parameter has a list of possible values.
         * @return <code>true</code> if this parameter has a list of possible values,
         * <code>false</code> otherwise.
         */
        public boolean
        hasPossibilities() { return possibilities != null; }
        
        /**
         * Returns the name of this parameter.
         * @return The name of this parameter.
         */
        public String
        toString() { return getName(); }
}
1	/*
2	* jlscp - a java LinuxSampler control protocol API
3	*
4	* Copyright (C) 2005-2006 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of jlscp.
7	*
8	* jlscp is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* jlscp is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with jlscp; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.linuxsampler.lscp;
24
25	/**
26	* This class provides default implementation of the <code>Parameter</code> interface.
27	*
28	* @author Grigor Iliev
29	*/
30	public abstract class AbstractParameter<T> implements Parameter<T>, Parseable {
31	private String name = null;
32	private ParameterType type = null;
33	private String desc = null;
34	private boolean fix = true;
35	private boolean multiplicity = true;
36
37	private boolean mandatory = false;
38	private String[] depends = null;
39
40	private T val = null;
41	private T dflt = null;
42	private Number rangeMin = null;
43	private Number rangeMax = null;
44	private T[] possibilities = null;
45
46
47	public
48	AbstractParameter() {
49
50	}
51
52	/**
53	* Gets the name of this parameter.
54	* @return The name of this parameter.
55	*/
56	public String
57	getName() { return name; }
58
59	/**
60	* Sets the name of this parameter.
61	* @param name A <code>String</code> object containing the new name for this parameter.
62	*/
63	public void
64	setName(String name) { this.name = name; }
65
66	/**
67	* Gets the description of this parameter.
68	* @return The description of this parameter.
69	*/
70	public String
71	getDescription() { return desc; }
72
73	/**
74	* Sets the description of this parameter.
75	* @param desc A <code>String</code> instance containing the description of this parameter.
76	*/
77	public void
78	setDescription(String desc) { this.desc = desc; }
79
80	/**
81	* Gets the type of this parameter.
82	* @return The type of this parameter.
83	*/
84	public ParameterType
85	getType() { return type; }
86
87	/**
88	* Sets the type of this parameter.
89	* @param type The type of this parameter.
90	*/
91	public void
92	setType(ParameterType type) { this.type = type; }
93
94	/**
95	* Gets the current value of this parameter.
96	* @return The current value of this parameter.
97	*/
98	public T
99	getValue() { return val; }
100
101	/**
102	* Sets the current value of this parameter.
103	* @param val The new value for this parameter.
104	*/
105	public void
106	setValue(T val) { this.val = val; }
107
108	/**
109	* Determines whether this parameter contains boolean value.
110	* @return <code>true</code> if this parameter contains boolean value,
111	* <code>false</code> otherwise.
112	*/
113	public boolean
114	isBoolean() { return type == ParameterType.BOOL; }
115
116	/**
117	* Determines whether this parameter contains integer value.
118	* @return <code>true</code> if this parameter contains integer value,
119	* <code>false</code> otherwise.
120	*/
121	public boolean
122	isInteger() { return type == ParameterType.INT; }
123
124	/**
125	* Determines whether this parameter contains float value.
126	* @return <code>true</code> if this parameter contains float value,
127	* <code>false</code> otherwise.
128	*/
129	public boolean
130	isFloat() { return type == ParameterType.FLOAT; }
131
132	/**
133	* Determines whether this parameter contains string value.
134	* @return <code>true</code> if this parameter contains string value,
135	* <code>false</code> otherwise.
136	*/
137	public boolean
138	isString() { return type == ParameterType.STRING; }
139
140	/**
141	* Determines whether this parameter contains list of boolean values.
142	* @return <code>true</code> if this parameter contains list of boolean values,
143	* <code>false</code> otherwise.
144	*/
145	public boolean
146	isBooleanList() { return type == ParameterType.BOOL_LIST; }
147
148	/**
149	* Determines whether this parameter contains list of integer values.
150	* @return <code>true</code> if this parameter contains list of integer values,
151	* <code>false</code> otherwise.
152	*/
153	public boolean
154	isIntegerList() { return type == ParameterType.INT_LIST; }
155
156	/**
157	* Determines whether this parameter contains list of float values.
158	* @return <code>true</code> if this parameter contains list of float values,
159	* <code>false</code> otherwise.
160	*/
161	public boolean
162	isFloatList() { return type == ParameterType.FLOAT_LIST; }
163
164	/**
165	* Determines whether this parameter contains list of string values.
166	* @return <code>true</code> if this parameter contains list of string values,
167	* <code>false</code> otherwise.
168	*/
169	public boolean
170	isStringList() { return type == ParameterType.STRING_LIST; }
171
172	/**
173	* Defines if this parameter can be altered.
174	* @return <code>true</code> if the parameter is readonly and <code>false</code>
175	* if the parameter can be altered.
176	*/
177	public boolean
178	isFixed() { return fix; }
179
180	/**
181	* Defines if this parameter allows only one value or list of values.
182	* @return <code>false</code> if this parameter allows only one value and <code>true</code>
183	* if allows a list of values.
184	*/
185	public boolean
186	isMultiplicity() { return multiplicity; }
187
188	/**
189	* Sets if this parameter allows only one value or list of values.
190	* @param b <code>true</code> if this parameter allows list of values,
191	* <code>false</code> otherwise.
192	*/
193	public void
194	setMultiplicity(boolean b) { multiplicity = b; }
195
196	/**
197	* Defines if this parameter must be given when the device is to be created.
198	* @return <code>true</code> if this parameter must be given when the device
199	* is to be created and <code>false</code> otherwise.
200	*/
201	public boolean
202	isMandatory() { return mandatory; }
203
204	/**
205	* Gets a <code>String</code> array with parameter's names this parameter depends on.
206	* @return A <code>String</code> array with parameter's names this parameter depends on
207	* or <code>null</code> if this parameter has no dependances.
208	*/
209	public String[]
210	getDependances() { return depends; }
211
212	/**
213	* Checks if this parameter depends on some other parameter(s).
214	* @return <code>true</code> if this parameter depends on some other parameter(s)
215	* and <code>false</code> otherwise.
216	*/
217	public boolean
218	hasDependances() { return depends != null; }
219
220	/**
221	* Parses a line of text.
222	* @param s A string to be parsed.
223	* @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
224	* @throws LscpException If some error occurs.
225	*/
226	public boolean
227	parse(String s) throws LscpException {
228	if(s.startsWith("DESCRIPTION: ")) {
229	desc = s.substring("DESCRIPTION: ".length(), s.length());
230	return true;
231	} else if(s.startsWith("FIX: ")) {
232	fix = Boolean.parseBoolean(s.substring("FIX: ".length(), s.length()));
233	return true;
234	} else if(s.startsWith("MANDATORY: ")) {
235	mandatory = Boolean.parseBoolean (
236	s.substring("MANDATORY: ".length(), s.length())
237	);
238	return true;
239	} else if(s.startsWith("DEPENDS: ")) {
240	s = s.substring("DEPENDS: ".length(), s.length());
241	depends = Parser.parseList(s);
242	return true;
243	}else if(s.startsWith("TYPE: ")) {
244
245	return true;
246	}else if(s.startsWith("MULTIPLICITY: ")) {
247
248	return true;
249	}
250
251	return false;
252	}
253
254	/**
255	* Parses the specified lines.
256	* @param lnS The lines to be parsed.
257	* @throws LscpException If some error occurs.
258	*/
259	protected void
260	parseLines(String[] lnS) throws LscpException {
261	for(String s : lnS) if(!parse(s)) {
262	Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
263	}
264	}
265
266	/**
267	* Gets the default value for this parameter.
268	* @return The default value for this parameter.
269	*/
270	public T
271	getDefault() { return dflt; }
272
273	/**
274	* Sets the default value for this parameter.
275	* @param dflt Specifies the default value for this parameter.
276	*/
277	public T
278	setDefault(T dflt) { return this.dflt = dflt; }
279
280	/**
281	* Gets the lower limit of the allowed value range for this parameter.
282	* @return The lower limit of the allowed value range for this
283	* parameter or <code>null</code> if the parameter doesn't have lower limit.
284	*/
285	public Number
286	getRangeMin() { return rangeMin; }
287
288	/**
289	* Sets the lower limit of the allowed value range for this parameter.
290	* @param min Specifies the lower limit of the allowed value range for this parameter.
291	*/
292	public void
293	setRangeMin(Number min) { rangeMin = min; }
294
295	/**
296	* Gets the upper limit of the allowed value range for this parameter.
297	* @return The upper limit of the allowed value range for this
298	* parameter or <code>null</code> if the parameter doesn't have upper limit.
299	*/
300	public Number
301	getRangeMax() { return rangeMax; }
302
303	/**
304	* Sets the upper limit of the allowed value range for this parameter.
305	* @param max Specifies the upper limit of the allowed value range for this parameter.
306	*/
307	public void
308	setRangeMax(Number max) { rangeMax = max; }
309
310	/**
311	* Gets a list of possible values for this parameter.
312	* @return A list of possible values for this parameter.
313	*/
314	public T[]
315	getPossibilities() { return possibilities; }
316
317	/**
318	* Sets the list of possible values for this parameter.
319	* @param pos The new list of possible values for this parameter.
320	*/
321	public void
322	setPossibilities(T[] pos) { possibilities = pos; }
323
324	/**
325	* Determines whether this parameter has a lower limit.
326	* @return <code>true</code> if this parameter has a lower limit,
327	* <code>false</code> otherwise.
328	*/
329	public boolean
330	hasRangeMin() { return rangeMin != null; }
331
332	/**
333	* Determines whether this parameter has an upper limit.
334	* @return <code>true</code> if this parameter has an upper limit,
335	* <code>false</code> otherwise.
336	*/
337	public boolean
338	hasRangeMax() { return rangeMax != null; }
339
340	/**
341	* Determines whether this parameter has a list of possible values.
342	* @return <code>true</code> if this parameter has a list of possible values,
343	* <code>false</code> otherwise.
344	*/
345	public boolean
346	hasPossibilities() { return possibilities != null; }
347
348	/**
349	* Returns the name of this parameter.
350	* @return The name of this parameter.
351	*/
352	public String
353	toString() { return getName(); }
354	}