1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
Copyright (C) 2001-2004 Stephane Magnenat & Luc-Olivier de Charrière
for any question or comment contact us at <stephane at magnenat dot net> or <NuageBleu at gmail dot com>
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 3 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
*/
#ifndef __TEXTSTREAM_H
#define __TEXTSTREAM_H
#include <Stream.h>
#include <StreamBackend.h>
#include <ostream>
#include <sstream>
#include <map>
#include <vector>
#include <set>
namespace GAGCore
{
//! Write data in a human readable form
class TextOutputStream : public OutputStream
{
protected:
StreamBackend *backend;
unsigned level;
//! print levels of tabs
void printLevel(void);
//! print string to backend
void printString(const char *string);
//! print a given type using ostringstream
template <class T>
void print(T v)
{
std::ostringstream oss;
oss << v;
printString(oss.str().c_str());
}
public:
TextOutputStream(StreamBackend *backend) { this->backend = backend; level=0; };
virtual ~TextOutputStream() { delete backend; }
virtual void write(const void *data, const size_t size, const char *name);
virtual void writeSint8(const Sint8 v, const char *name) { printLevel(); printString(name); printString(" = "); print<signed>(v); print(";\n"); }
virtual void writeUint8(const Uint8 v, const char *name) { printLevel(); printString(name); printString(" = "); print<unsigned>(v); print(";\n"); }
virtual void writeSint16(const Sint16 v, const char *name) { printLevel(); printString(name); printString(" = "); print<signed>(v); print(";\n"); }
virtual void writeUint16(const Uint16 v, const char *name) { printLevel(); printString(name); printString(" = "); print<unsigned>(v); print(";\n"); }
virtual void writeSint32(const Sint32 v, const char *name) { printLevel(); printString(name); printString(" = "); print(v); print(";\n"); }
virtual void writeUint32(const Uint32 v, const char *name) { printLevel(); printString(name); printString(" = "); print(v); print(";\n"); }
virtual void writeFloat(const float v, const char *name) { printLevel(); printString(name); printString(" = "); print(v); print(";\n"); }
virtual void writeDouble(const double v, const char *name) { printLevel(); printString(name); printString(" = "); print(v); print(";\n"); }
virtual void writeText(const std::string &v, const char *name);
virtual void flush(void) { backend->flush(); }
virtual void writeEnterSection(const char *name);
virtual void writeEnterSection(unsigned id);
virtual void writeLeaveSection(size_t count = 1);
virtual bool canSeek(void) { return false; }
virtual void seekFromStart(int displacement) { }
virtual void seekFromEnd(int displacement) { }
virtual void seekRelative(int displacement) { }
virtual size_t getPosition(void) { return backend->getPosition(); }
virtual bool isEndOfStream(void) { return backend->isEndOfStream(); }
};
//! Read data from a human readable form, C-like, supporting C and C++ comments
class TextInputStream : public InputStream
{
protected:
//! table of parsed value
std::map<std::string, std::string> table;
//! recursive keys
std::vector<std::string> levels;
//! actual complete key
std::string key;
//! Read from table using keys key and name and put result to result
void readFromTableToString(const char *name, std::string *result);
//! read from table and convert to type T using std::istringstream
template <class T>
T readFromTable(const char *name)
{
std::string s;
readFromTableToString(name, &s);
std::istringstream iss(s);
T v;
iss >> v;
return v;
}
public:
//! Constructor. Uses backend, but does not delete it
TextInputStream(StreamBackend *backend);
//! Return all subsections of root
void getSubSections(const std::string &root, std::set<std::string> *sections);
virtual void read(void *data, size_t size, const char *name);
virtual Sint8 readSint8(const char *name) { return static_cast<Sint8>(readFromTable<signed>(name)); }
virtual Uint8 readUint8(const char *name) { return static_cast<Uint8>(readFromTable<unsigned>(name)); }
virtual Sint16 readSint16(const char *name) { return static_cast<Sint16>(readFromTable<signed>(name)); }
virtual Uint16 readUint16(const char *name) { return static_cast<Uint16>(readFromTable<unsigned>(name)); }
virtual Sint32 readSint32(const char *name) { return readFromTable<Sint32>(name); }
virtual Uint32 readUint32(const char *name) { return readFromTable<Uint32>(name); }
virtual float readFloat(const char *name) { return readFromTable<float>(name); }
virtual double readDouble(const char *name) { return readFromTable<double>(name); }
virtual std::string readText(const char *name) { std::string s; readFromTableToString(name, &s); return s; }
virtual void readEnterSection(const char *name);
virtual void readEnterSection(unsigned id);
virtual void readLeaveSection(size_t count = 1);
virtual bool canSeek(void) { return false; }
virtual void seekFromStart(int displacement) { }
virtual void seekFromEnd(int displacement) { }
virtual void seekRelative(int displacement) { }
virtual size_t getPosition(void) { return 0; }
virtual bool isEndOfStream(void) { return false; }
};
}
#endif
|
