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

Subversion Repositories gelsvn

(root)/trunk/src/Util/Parse.cpp – Rev 425 → 595