linuxsampler/lscp/FloatParameter.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 implements the <code>Parameter&lt;Float&gt;</code> interface.
 *
 * @author  Grigor Iliev
 */
public class FloatParameter extends AbstractParameter<Float> {
        /** Creates a new instance of <code>FloatParameter</code> */
        public
        FloatParameter() {
                setType(ParameterType.FLOAT);
                setMultiplicity(false);
        }
        
        /**
         * Creates a <code>FloatParameter</code> instance with the specified name.
         * @param name The parameter name.
         */
        public
        FloatParameter(String name) {
                this(name, null);
        }
        
        /**
         * Creates a <code>FloatParameter</code> instance with the specified name and value.
         * @param name The parameter name.
         * @param value The parameter value.
         */
        public
        FloatParameter(String name, Float value) {
                this();
                setName(name);
                setValue(value);
        }
        
        /**
         * Creates a new instance of <code>FloatParameter</code>
         * and parses the specified lines.
         * @param lnS A <code>String</code> array with lines to be parsed.
         * @throws LscpException If the parse fail.
         */
        protected
        FloatParameter(String[] lnS) throws LscpException {
                this();
                parseLines(lnS);
        }
        
        /**
         * Parses a line of text.
         * @param s The 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(super.parse(s)) return true;
                else if(s.startsWith("RANGE_MIN: ")) {
                        s = s.substring("RANGE_MIN: ".length(), s.length());
                        try {
                                setRangeMin(Float.parseFloat(s));
                                return true;
                        } catch(NumberFormatException x) { throw new LscpException (
                                LscpI18n.getLogMsg("notFloat!", "RANGE_MIN"), x
                        );}
                } else if(s.startsWith("RANGE_MAX: ")) {
                        s = s.substring("RANGE_MAX: ".length(), s.length());
                        try {
                                setRangeMax(Float.parseFloat(s));
                                return true;
                        } catch(NumberFormatException x) { throw new LscpException (
                                LscpI18n.getLogMsg("notFloat!", "RANGE_MAX"), x
                        );}
                } else if(s.startsWith("DEFAULT: ")) {
                        s = s.substring("DEFAULT: ".length(), s.length());
                        try {
                                setDefault(Float.parseFloat(s));
                                return true;
                        } catch(NumberFormatException x) { throw new LscpException (
                                LscpI18n.getLogMsg("notFloat!", "DEFAULT"), x
                        );}     
                } else if(s.startsWith("POSSIBILITIES: ")) {
                        s = s.substring("POSSIBILITIES: ".length(), s.length());
                        setPossibilities(Parser.parseFloatList(s));
                        return true;
                }
                
                return false;
        }
        
        /**
         * Parses the specified character string and sets the value of this parameter
         * with the parsed result.
         * @param s A character string containing the value to be parsed.
         * @throws LscpException If the parsing failed.
         */
        public void
        parseValue(String s) throws LscpException {
                setValue(Parser.parseFloat(s));
        }
        
        /**
         * Gets a character string representation of the parameter's value.
         * @return A character string representation of the parameter's value.
         */
        public String
        getStringValue() { return String.valueOf(getValue()); }
}
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 implements the <code>Parameter<Float></code> interface.
27	*
28	* @author Grigor Iliev
29	*/
30	public class FloatParameter extends AbstractParameter<Float> {
31	/** Creates a new instance of <code>FloatParameter</code> */
32	public
33	FloatParameter() {
34	setType(ParameterType.FLOAT);
35	setMultiplicity(false);
36	}
37
38	/**
39	* Creates a <code>FloatParameter</code> instance with the specified name.
40	* @param name The parameter name.
41	*/
42	public
43	FloatParameter(String name) {
44	this(name, null);
45	}
46
47	/**
48	* Creates a <code>FloatParameter</code> instance with the specified name and value.
49	* @param name The parameter name.
50	* @param value The parameter value.
51	*/
52	public
53	FloatParameter(String name, Float value) {
54	this();
55	setName(name);
56	setValue(value);
57	}
58
59	/**
60	* Creates a new instance of <code>FloatParameter</code>
61	* and parses the specified lines.
62	* @param lnS A <code>String</code> array with lines to be parsed.
63	* @throws LscpException If the parse fail.
64	*/
65	protected
66	FloatParameter(String[] lnS) throws LscpException {
67	this();
68	parseLines(lnS);
69	}
70
71	/**
72	* Parses a line of text.
73	* @param s The string to be parsed.
74	* @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
75	* @throws LscpException If some error occurs.
76	*/
77	public boolean
78	parse(String s) throws LscpException {
79	if(super.parse(s)) return true;
80	else if(s.startsWith("RANGE_MIN: ")) {
81	s = s.substring("RANGE_MIN: ".length(), s.length());
82	try {
83	setRangeMin(Float.parseFloat(s));
84	return true;
85	} catch(NumberFormatException x) { throw new LscpException (
86	LscpI18n.getLogMsg("notFloat!", "RANGE_MIN"), x
87	);}
88	} else if(s.startsWith("RANGE_MAX: ")) {
89	s = s.substring("RANGE_MAX: ".length(), s.length());
90	try {
91	setRangeMax(Float.parseFloat(s));
92	return true;
93	} catch(NumberFormatException x) { throw new LscpException (
94	LscpI18n.getLogMsg("notFloat!", "RANGE_MAX"), x
95	);}
96	} else if(s.startsWith("DEFAULT: ")) {
97	s = s.substring("DEFAULT: ".length(), s.length());
98	try {
99	setDefault(Float.parseFloat(s));
100	return true;
101	} catch(NumberFormatException x) { throw new LscpException (
102	LscpI18n.getLogMsg("notFloat!", "DEFAULT"), x
103	);}
104	} else if(s.startsWith("POSSIBILITIES: ")) {
105	s = s.substring("POSSIBILITIES: ".length(), s.length());
106	setPossibilities(Parser.parseFloatList(s));
107	return true;
108	}
109
110	return false;
111	}
112
113	/**
114	* Parses the specified character string and sets the value of this parameter
115	* with the parsed result.
116	* @param s A character string containing the value to be parsed.
117	* @throws LscpException If the parsing failed.
118	*/
119	public void
120	parseValue(String s) throws LscpException {
121	setValue(Parser.parseFloat(s));
122	}
123
124	/**
125	* Gets a character string representation of the parameter's value.
126	* @return A character string representation of the parameter's value.
127	*/
128	public String
129	getStringValue() { return String.valueOf(getValue()); }
130	}