WebSVN – gelsvn – Diff – /branches/cpp11-devel/src/Util/Parse.cpp


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

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/src/Util/Parse.cpp – Rev 595 → 630