src/network/lscpresultset.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2016 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

/*********************************************************
 * This class helps to constuct valid resultsets per
 * LSCP protocol specification
 *
 * Valid results include:
 * OK - to ack the request
 * Single line to ack the requests and give status
 * Several lines of information in the following format:
 * LABEL0: VALUE0
 * LABEL1: VALUE1
 * VALELx: VALUEx
 * .
 *
 * ******************************************************/

#include "lscpresultset.h"
#include <iomanip>
#include "../common/global_private.h"


namespace LinuxSampler {

//Construct an empty resultset
//Default index is -1 meaning the resultset doesn't have an index
LSCPResultSet::LSCPResultSet(int index) {
        result_index = index;
        count = 0;
        storage = "";
        result_type = result_type_success;
}

//Construct a resultset with a single line
//Default index is -1 meaning the resultset doesn't have an index
LSCPResultSet::LSCPResultSet(String Value, int index) {
        result_index = index;
        count = 1;
        storage = Value + "\r\n";
        result_type = result_type_success;
}

//Add a label/value pair to the resultset
//Values could be of different types for now supports String, int and float.
void LSCPResultSet::Add(String Label, String Value) {
        if (count == -1)
                throw Exception("Attempting to change already produced resultset");
        if (result_type != result_type_success)
                throw Exception("Attempting to create illegal resultset");
        storage = storage + Label + ": " + Value + "\r\n";
        count = 2; // results in form of "Label: Value" should always be handled as multi line responses
}

void LSCPResultSet::Add(String Label, const char* pValue) {
    Add(Label, String(pValue));
}

//Add SQL resultset row
void LSCPResultSet::Add(int columns, char** argv) {
        for (int i = 0; i < columns; i++)
        {
                storage += argv[i];
                if ((i+1) < columns)
                        storage += "|";
        }
        storage += "\r\n";
        count = 2; //This result is always multiline.
}

void LSCPResultSet::Add(int Value) {
        Add(ToString(Value));
}

void LSCPResultSet::Add(String Label, int Value) {
        Add(Label, ToString(Value));
}

void LSCPResultSet::Add(String Label, float Value) {
    std::stringstream ss;
    ss.imbue(std::locale::classic());
    ss << std::fixed << std::setprecision(3) << Value;
    Add(Label, ss.str());
}

void LSCPResultSet::Add(String Label, bool Value) {
    String s = (Value) ? "true" : "false";
    Add(Label, s);
}

//Add a single string to the resultset
void LSCPResultSet::Add(String Value) {
        if (result_type != result_type_success)
                throw Exception("Attempting to create illegal resultset");
        if (count == -1)
                throw Exception("Attempting to change already produced resultset");
        if (count != 0)
                throw Exception("Attempting to create illegal resultset");
        storage = Value + "\r\n";
        count = 1;
}

void LSCPResultSet::Add(String Label, const std::vector<float>& v) {
    std::stringstream ss;
    ss.imbue(std::locale::classic());
    for (int i = 0; i < v.size(); i++) {
        if (!ss.str().empty()) ss << ",";
        ss << std::fixed << std::setprecision(3) << v[i];
    }
    Add(Label, ss.str());    
}

//Generate an error result set from an exception.
//Per LSCP spec, error result is a sinle line in the following format:
//ERR:<CODE>:Message text\r\n
//This method will be used to generate unknown errors only (code 0)
//To generate errors with other codes as well as warnings use other methods (below).
//Because this is an unknown error, this method will also print message to the stderr.
void LSCPResultSet::Error(Exception e) {
        e.PrintMessage();
        Error(e.Message());
}

//This will construct an error with a string and error code
//code has a default of 0
//String has a default of "Undefined Error"
void LSCPResultSet::Error (String message, int code) {
        //Even though this is must be a single line resultset we won't throw
        //anything here because this is already part of exception handling.
        //We'll just 'forget' all previous results (if any) from this resultset.
        result_type = result_type_error;
        storage = "ERR:" + ToString(code) + ":" + message + "\r\n";
        count = 1;
}

//This will construct a warning with a string and error code
//code has a default of 0
//String has a default of "Undefined Error"
void LSCPResultSet::Warning (String message, int code) {
        //FIXME: DO we want warnings as part of the resultset or
        //do we want them to work like errors??? For now, make them work like errors.
        result_type = result_type_warning;
        if (result_index == -1)
                storage = "WRN:" + ToString(code) + ":" + message + "\r\n";
        else
                storage = "WRN[" + ToString(result_index) + "]:" + ToString(code) + ":" + message + "\r\n";
        count = 1;
}

//Produce resultset
String LSCPResultSet::Produce(void) {
        //FIXME: I'm assuming that only a sinle like "OK" can have index
        if (count == 0) { //When there is nothing in the resultset we just send "OK" to ack the request
                if (result_index == -1)
                        return "OK\r\n";
                else
                        return "OK[" + ToString(result_index) + "]\r\n";
    }
        if (count == 1) //Single line results are just that, single line
                return storage;
        //Multiline results MUST end with a line with a single dot
        return storage + ".\r\n";
}

}
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005 - 2016 Christian Schoenebeck *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License *
19	* along with this program; if not, write to the Free Software *
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21	* MA 02111-1307 USA *
22	***************************************************************************/
23
24	/*********************************************************
25	* This class helps to constuct valid resultsets per
26	* LSCP protocol specification
27	*
28	* Valid results include:
29	* OK - to ack the request
30	* Single line to ack the requests and give status
31	* Several lines of information in the following format:
32	* LABEL0: VALUE0
33	* LABEL1: VALUE1
34	* VALELx: VALUEx
35	* .
36	*
37	* ******************************************************/
38
39	#include "lscpresultset.h"
40	#include <iomanip>
41	#include "../common/global_private.h"
42
43
44	namespace LinuxSampler {
45
46	//Construct an empty resultset
47	//Default index is -1 meaning the resultset doesn't have an index
48	LSCPResultSet::LSCPResultSet(int index) {
49	result_index = index;
50	count = 0;
51	storage = "";
52	result_type = result_type_success;
53	}
54
55	//Construct a resultset with a single line
56	//Default index is -1 meaning the resultset doesn't have an index
57	LSCPResultSet::LSCPResultSet(String Value, int index) {
58	result_index = index;
59	count = 1;
60	storage = Value + "\r\n";
61	result_type = result_type_success;
62	}
63
64	//Add a label/value pair to the resultset
65	//Values could be of different types for now supports String, int and float.
66	void LSCPResultSet::Add(String Label, String Value) {
67	if (count == -1)
68	throw Exception("Attempting to change already produced resultset");
69	if (result_type != result_type_success)
70	throw Exception("Attempting to create illegal resultset");
71	storage = storage + Label + ": " + Value + "\r\n";
72	count = 2; // results in form of "Label: Value" should always be handled as multi line responses
73	}
74
75	void LSCPResultSet::Add(String Label, const char* pValue) {
76	Add(Label, String(pValue));
77	}
78
79	//Add SQL resultset row
80	void LSCPResultSet::Add(int columns, char** argv) {
81	for (int i = 0; i < columns; i++)
82	{
83	storage += argv[i];
84	if ((i+1) < columns)
85	storage += "\|";
86	}
87	storage += "\r\n";
88	count = 2; //This result is always multiline.
89	}
90
91	void LSCPResultSet::Add(int Value) {
92	Add(ToString(Value));
93	}
94
95	void LSCPResultSet::Add(String Label, int Value) {
96	Add(Label, ToString(Value));
97	}
98
99	void LSCPResultSet::Add(String Label, float Value) {
100	std::stringstream ss;
101	ss.imbue(std::locale::classic());
102	ss << std::fixed << std::setprecision(3) << Value;
103	Add(Label, ss.str());
104	}
105
106	void LSCPResultSet::Add(String Label, bool Value) {
107	String s = (Value) ? "true" : "false";
108	Add(Label, s);
109	}
110
111	//Add a single string to the resultset
112	void LSCPResultSet::Add(String Value) {
113	if (result_type != result_type_success)
114	throw Exception("Attempting to create illegal resultset");
115	if (count == -1)
116	throw Exception("Attempting to change already produced resultset");
117	if (count != 0)
118	throw Exception("Attempting to create illegal resultset");
119	storage = Value + "\r\n";
120	count = 1;
121	}
122
123	void LSCPResultSet::Add(String Label, const std::vector<float>& v) {
124	std::stringstream ss;
125	ss.imbue(std::locale::classic());
126	for (int i = 0; i < v.size(); i++) {
127	if (!ss.str().empty()) ss << ",";
128	ss << std::fixed << std::setprecision(3) << v[i];
129	}
130	Add(Label, ss.str());
131	}
132
133	//Generate an error result set from an exception.
134	//Per LSCP spec, error result is a sinle line in the following format:
135	//ERR:<CODE>:Message text\r\n
136	//This method will be used to generate unknown errors only (code 0)
137	//To generate errors with other codes as well as warnings use other methods (below).
138	//Because this is an unknown error, this method will also print message to the stderr.
139	void LSCPResultSet::Error(Exception e) {
140	e.PrintMessage();
141	Error(e.Message());
142	}
143
144	//This will construct an error with a string and error code
145	//code has a default of 0
146	//String has a default of "Undefined Error"
147	void LSCPResultSet::Error (String message, int code) {
148	//Even though this is must be a single line resultset we won't throw
149	//anything here because this is already part of exception handling.
150	//We'll just 'forget' all previous results (if any) from this resultset.
151	result_type = result_type_error;
152	storage = "ERR:" + ToString(code) + ":" + message + "\r\n";
153	count = 1;
154	}
155
156	//This will construct a warning with a string and error code
157	//code has a default of 0
158	//String has a default of "Undefined Error"
159	void LSCPResultSet::Warning (String message, int code) {
160	//FIXME: DO we want warnings as part of the resultset or
161	//do we want them to work like errors??? For now, make them work like errors.
162	result_type = result_type_warning;
163	if (result_index == -1)
164	storage = "WRN:" + ToString(code) + ":" + message + "\r\n";
165	else
166	storage = "WRN[" + ToString(result_index) + "]:" + ToString(code) + ":" + message + "\r\n";
167	count = 1;
168	}
169
170	//Produce resultset
171	String LSCPResultSet::Produce(void) {
172	//FIXME: I'm assuming that only a sinle like "OK" can have index
173	if (count == 0) { //When there is nothing in the resultset we just send "OK" to ack the request
174	if (result_index == -1)
175	return "OK\r\n";
176	else
177	return "OK[" + ToString(result_index) + "]\r\n";
178	}
179	if (count == 1) //Single line results are just that, single line
180	return storage;
181	//Multiline results MUST end with a line with a single dot
182	return storage + ".\r\n";
183	}
184
185	}