WebSVN – gelsvn – Diff – /trunk/src/Util/Parse.cpp


#include "Parse.h"
#include <cstring>
#include <cstdlib>
#include <iostream>
 
using namespace std;
using namespace CGLA;
 
namespace
{
	const char seps[]   = " ,\t\n";
 
	inline char* next_etoken(const char* btoken)
	{
		return const_cast<char*>(btoken)+strcspn(btoken, seps);
	}
	
	inline const char* next_btoken(char* etoken)
	{
		return const_cast<const char*>(etoken+strspn(etoken, seps));
	}
}
 
namespace Util {
	string floatToString(float value) {
		stringstream ret;
		string stringret;
		ret << value;
		getline(ret,stringret);
		return stringret;
	}
 
	void parse(const char* str,bool& x) {
		x = (strcmp(str,"true")==0) || (strcmp(str,"TRUE")==0);
	}
 
	void parse(const char* str,string& x) {
		x=string(str);
	}
 
	void parse(const char* str,int& x) {
		/* Establish string and get the first token: */
 
		x = strtol(str,0,10);
	} 
 
	void parse(const char* str,Vec2i& vec)
	{   /* Establish string and get the first token: */
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken=next_etoken(btoken);
		vec[0] = strtol(btoken,0,10);
		btoken= next_btoken(etoken);
		etoken= next_etoken(btoken);
		vec[1] = strtol(btoken,0,10);
	}
 
 
	void parse(const char* str,float& x) 
	{
		/* Establish string and get the first token: */
 
		x = strtod(str,0);
	}
 
	void parse(const char* str,Vec2f& vec) {
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		vec[0] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[1] = strtod(btoken,0);
	}
 
	void parse(const char* str,Vec3f& vec) {
   /* Establish string and get the first token: */
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		vec[0] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[1] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[2] = strtod(btoken,0);
	}
 
 
	void parse(const char* str,Vec4f& vec) {
   /* Establish string and get the first token: */
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		vec[0] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[1] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[2] = strtod(btoken,0);
		btoken=next_btoken(etoken);
		etoken=next_etoken(btoken);
		vec[3] = strtod(btoken,0);
	}
 
	void parse(const char* str,vector<float>& v) {
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		while(etoken>btoken)
		{
			v.push_back(strtod(btoken,0));
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
		}
	}
 
	void parse(const char* str,vector<Vec2f>& v) {
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		while(etoken>btoken)
		{
			Vec2f vec;
			vec[0] = strtod(btoken,0);
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
			vec[1] = strtod(btoken,0);
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
			v.push_back(vec);
		}
	}
 
	void parse(const char* str,vector<Vec3f>& v) {
   /* Establish string and get the first token: */
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		while(etoken>btoken)
		{
			Vec3f vec;
			vec[0] = strtod(btoken,0);
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
			vec[1] = strtod(btoken,0);
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
			vec[2] = strtod(btoken,0);
			btoken=next_btoken(etoken);
			etoken=next_etoken(btoken);
			v.push_back(vec);
		}
	}
 
	void parse(const char* str,vector<int>& v) 
	{
 
		const char *btoken=next_btoken(const_cast<char*>(str));
		char *etoken= next_etoken(btoken);
		while(etoken>btoken)
			{
				v.push_back(strtol(btoken,0,10));
				btoken=next_btoken(etoken);
				etoken=next_etoken(btoken);
			}
	}
	
}
 

Rev 39	Rev 136
1	`#include "Parse.h"`	1	`#include "Parse.h"`
2	`#include <cstring>`	2	`#include <cstring>`
3	`#include <cstdlib>`	3	`#include <cstdlib>`
4	`#include <iostream>`	4	`#include <iostream>`
5		5
6	`using namespace std;`	6	`using namespace std;`
7	`using namespace CGLA;`	7	`using namespace CGLA;`
8		8
9	`namespace`	9	`namespace`
10	`{`	10	`{`
11	`const char seps[] = " ,\t\n";`	11	`const char seps[] = " ,\t\n";`
12		12
13	`inline char* next_etoken(const char* btoken)`	13	`inline char* next_etoken(const char* btoken)`
14	`{`	14	`{`
15	`return const_cast<char*>(btoken)+strcspn(btoken, seps);`	15	`return const_cast<char*>(btoken)+strcspn(btoken, seps);`
16	`}`	16	`}`
17		17
18	`inline const char* next_btoken(char* etoken)`	18	`inline const char* next_btoken(char* etoken)`
19	`{`	19	`{`
20	`return const_cast<const char*>(etoken+strspn(etoken, seps));`	20	`return const_cast<const char*>(etoken+strspn(etoken, seps));`
21	`}`	21	`}`
22	`}`	22	`}`
23		23
24	`namespace Util {`	24	`namespace Util {`
25	`string floatToString(float value) {`	25	`string floatToString(float value) {`
26	`stringstream ret;`	26	`stringstream ret;`
27	`string stringret;`	27	`string stringret;`
28	`ret << value;`	28	`ret << value;`
29	`getline(ret,stringret);`	29	`getline(ret,stringret);`
30	`return stringret;`	30	`return stringret;`
31	`}`	31	`}`
32		32
33	`void parse(const char* str,bool& x) {`	33	`void parse(const char* str,bool& x) {`
34	`x = (strcmp(str,"true")==0) \|\| (strcmp(str,"TRUE")==0);`	34	`x = (strcmp(str,"true")==0) \|\| (strcmp(str,"TRUE")==0);`
35	`}`	35	`}`
36		36
37	`void parse(const char* str,string& x) {`	37	`void parse(const char* str,string& x) {`
38	`x=string(str);`	38	`x=string(str);`
39	`}`	39	`}`
40		40
41	`void parse(const char* str,int& x) {`	41	`void parse(const char* str,int& x) {`
42	`/* Establish string and get the first token: */`	42	`/* Establish string and get the first token: */`
43	`char *etoken=0;`	-
44	`x = strtol(str,0,10);`	43	`x = strtol(str,0,10);`
45	`}`	44	`}`
46		45
47	`void parse(const char* str,Vec2i& vec)`	46	`void parse(const char* str,Vec2i& vec)`
48	`{ /* Establish string and get the first token: */`	47	`{ /* Establish string and get the first token: */`
49	`const char btoken=next_btoken(const_cast<char>(str));`	48	`const char btoken=next_btoken(const_cast<char>(str));`
50	`char *etoken=next_etoken(btoken);`	49	`char *etoken=next_etoken(btoken);`
51	`vec[0] = strtol(btoken,0,10);`	50	`vec[0] = strtol(btoken,0,10);`
52	`btoken= next_btoken(etoken);`	51	`btoken= next_btoken(etoken);`
53	`etoken= next_etoken(btoken);`	52	`etoken= next_etoken(btoken);`
54	`vec[1] = strtol(btoken,0,10);`	53	`vec[1] = strtol(btoken,0,10);`
55	`}`	54	`}`
56		55
57		56
58	`void parse(const char* str,float& x)`	57	`void parse(const char* str,float& x)`
59	`{`	58	`{`
60	`/* Establish string and get the first token: */`	59	`/* Establish string and get the first token: */`
61	`char *etoken=0;`	-
62	`x = strtod(str,0);`	60	`x = strtod(str,0);`
63	`}`	61	`}`
64		62
65	`void parse(const char* str,Vec2f& vec) {`	63	`void parse(const char* str,Vec2f& vec) {`
66	`const char seps[] = " ,\t\n";`	-
67	`const char btoken=next_btoken(const_cast<char>(str));`	64	`const char btoken=next_btoken(const_cast<char>(str));`
68	`char *etoken= next_etoken(btoken);`	65	`char *etoken= next_etoken(btoken);`
69	`vec[0] = strtod(btoken,0);`	66	`vec[0] = strtod(btoken,0);`
70	`btoken=next_btoken(etoken);`	67	`btoken=next_btoken(etoken);`
71	`etoken=next_etoken(btoken);`	68	`etoken=next_etoken(btoken);`
72	`vec[1] = strtod(btoken,0);`	69	`vec[1] = strtod(btoken,0);`
73	`}`	70	`}`
74		71
75	`void parse(const char* str,Vec3f& vec) {`	72	`void parse(const char* str,Vec3f& vec) {`
76	`/* Establish string and get the first token: */`	73	`/* Establish string and get the first token: */`
77	`const char seps[] = " ,\t\n";`	-
78	`const char btoken=next_btoken(const_cast<char>(str));`	74	`const char btoken=next_btoken(const_cast<char>(str));`
79	`char *etoken= next_etoken(btoken);`	75	`char *etoken= next_etoken(btoken);`
80	`vec[0] = strtod(btoken,0);`	76	`vec[0] = strtod(btoken,0);`
81	`btoken=next_btoken(etoken);`	77	`btoken=next_btoken(etoken);`
82	`etoken=next_etoken(btoken);`	78	`etoken=next_etoken(btoken);`
83	`vec[1] = strtod(btoken,0);`	79	`vec[1] = strtod(btoken,0);`
84	`btoken=next_btoken(etoken);`	80	`btoken=next_btoken(etoken);`
85	`etoken=next_etoken(btoken);`	81	`etoken=next_etoken(btoken);`
86	`vec[2] = strtod(btoken,0);`	82	`vec[2] = strtod(btoken,0);`
87	`}`	83	`}`
88		84
89		85
90	`void parse(const char* str,Vec4f& vec) {`	86	`void parse(const char* str,Vec4f& vec) {`
91	`/* Establish string and get the first token: */`	87	`/* Establish string and get the first token: */`
92	`const char seps[] = " ,\t\n";`	-
93	`const char btoken=next_btoken(const_cast<char>(str));`	88	`const char btoken=next_btoken(const_cast<char>(str));`
94	`char *etoken= next_etoken(btoken);`	89	`char *etoken= next_etoken(btoken);`
95	`vec[0] = strtod(btoken,0);`	90	`vec[0] = strtod(btoken,0);`
96	`btoken=next_btoken(etoken);`	91	`btoken=next_btoken(etoken);`
97	`etoken=next_etoken(btoken);`	92	`etoken=next_etoken(btoken);`
98	`vec[1] = strtod(btoken,0);`	93	`vec[1] = strtod(btoken,0);`
99	`btoken=next_btoken(etoken);`	94	`btoken=next_btoken(etoken);`
100	`etoken=next_etoken(btoken);`	95	`etoken=next_etoken(btoken);`
101	`vec[2] = strtod(btoken,0);`	96	`vec[2] = strtod(btoken,0);`
102	`btoken=next_btoken(etoken);`	97	`btoken=next_btoken(etoken);`
103	`etoken=next_etoken(btoken);`	98	`etoken=next_etoken(btoken);`
104	`vec[3] = strtod(btoken,0);`	99	`vec[3] = strtod(btoken,0);`
105	`}`	100	`}`
106		101
107	`void parse(const char* str,vector<float>& v) {`	102	`void parse(const char* str,vector<float>& v) {`
108	`const char seps[] = " ,\t\n";`	-
109	`const char btoken=next_btoken(const_cast<char>(str));`	103	`const char btoken=next_btoken(const_cast<char>(str));`
110	`char *etoken= next_etoken(btoken);`	104	`char *etoken= next_etoken(btoken);`
111	`while(etoken>btoken)`	105	`while(etoken>btoken)`
112	`{`	106	`{`
113	`v.push_back(strtod(btoken,0));`	107	`v.push_back(strtod(btoken,0));`
114	`btoken=next_btoken(etoken);`	108	`btoken=next_btoken(etoken);`
115	`etoken=next_etoken(btoken);`	109	`etoken=next_etoken(btoken);`
116	`}`	110	`}`
117	`}`	111	`}`
118		112
119	`void parse(const char* str,vector<Vec2f>& v) {`	113	`void parse(const char* str,vector<Vec2f>& v) {`
120	`const char seps[] = " ,\t\n";`	-
121	`const char btoken=next_btoken(const_cast<char>(str));`	114	`const char btoken=next_btoken(const_cast<char>(str));`
122	`char *etoken= next_etoken(btoken);`	115	`char *etoken= next_etoken(btoken);`
123	`while(etoken>btoken)`	116	`while(etoken>btoken)`
124	`{`	117	`{`
125	`Vec2f vec;`	118	`Vec2f vec;`
126	`vec[0] = strtod(btoken,0);`	119	`vec[0] = strtod(btoken,0);`
127	`btoken=next_btoken(etoken);`	120	`btoken=next_btoken(etoken);`
128	`etoken=next_etoken(btoken);`	121	`etoken=next_etoken(btoken);`
129	`vec[1] = strtod(btoken,0);`	122	`vec[1] = strtod(btoken,0);`
130	`btoken=next_btoken(etoken);`	123	`btoken=next_btoken(etoken);`
131	`etoken=next_etoken(btoken);`	124	`etoken=next_etoken(btoken);`
132	`v.push_back(vec);`	125	`v.push_back(vec);`
133	`}`	126	`}`
134	`}`	127	`}`
135		128
136	`void parse(const char* str,vector<Vec3f>& v) {`	129	`void parse(const char* str,vector<Vec3f>& v) {`
137	`/* Establish string and get the first token: */`	130	`/* Establish string and get the first token: */`
138	`const char seps[] = " ,\t\n";`	-
139	`const char btoken=next_btoken(const_cast<char>(str));`	131	`const char btoken=next_btoken(const_cast<char>(str));`
140	`char *etoken= next_etoken(btoken);`	132	`char *etoken= next_etoken(btoken);`
141	`while(etoken>btoken)`	133	`while(etoken>btoken)`
142	`{`	134	`{`
143	`Vec3f vec;`	135	`Vec3f vec;`
144	`vec[0] = strtod(btoken,0);`	136	`vec[0] = strtod(btoken,0);`
145	`btoken=next_btoken(etoken);`	137	`btoken=next_btoken(etoken);`
146	`etoken=next_etoken(btoken);`	138	`etoken=next_etoken(btoken);`
147	`vec[1] = strtod(btoken,0);`	139	`vec[1] = strtod(btoken,0);`
148	`btoken=next_btoken(etoken);`	140	`btoken=next_btoken(etoken);`
149	`etoken=next_etoken(btoken);`	141	`etoken=next_etoken(btoken);`
150	`vec[2] = strtod(btoken,0);`	142	`vec[2] = strtod(btoken,0);`
151	`btoken=next_btoken(etoken);`	143	`btoken=next_btoken(etoken);`
152	`etoken=next_etoken(btoken);`	144	`etoken=next_etoken(btoken);`
153	`v.push_back(vec);`	145	`v.push_back(vec);`
154	`}`	146	`}`
155	`}`	147	`}`
156		148
157	`void parse(const char* str,vector<int>& v)`	149	`void parse(const char* str,vector<int>& v)`
158	`{`	150	`{`
159	`const char seps[] = " ,\t\n";`	-
160	`const char btoken=next_btoken(const_cast<char>(str));`	151	`const char btoken=next_btoken(const_cast<char>(str));`
161	`char *etoken= next_etoken(btoken);`	152	`char *etoken= next_etoken(btoken);`
162	`while(etoken>btoken)`	153	`while(etoken>btoken)`
163	`{`	154	`{`
164	`v.push_back(strtol(btoken,0,10));`	155	`v.push_back(strtol(btoken,0,10));`
165	`btoken=next_btoken(etoken);`	156	`btoken=next_btoken(etoken);`
166	`etoken=next_etoken(btoken);`	157	`etoken=next_etoken(btoken);`
167	`}`	158	`}`
168	`}`	159	`}`
169		160
170	`}`	161	`}`
171		162

Subversion Repositories gelsvn

(root)/trunk/src/Util/Parse.cpp – Rev 39 → 136