Subversion Repositories gelsvn

Rev

Rev 425 | Details | Compare with Previous | Last modification | View Log | RSS feed

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