Subversion Repositories spk

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
114 cycrow 1 
 
2 
#ifndef BOB_X2FILE_STREAM_INCLUDED
3 
#define BOB_X2FILE_STREAM_INCLUDED
4 
 
5 
#include "../common/file_stream.h"
6 
#include "../filedriver/x2fd.h"
7 
 
8 
/*
9 
	bob_dom_obinaryX2file - output binary stream (x2 filesystem files)
10 
	bob_dom_otextX2file - output text stream (x2 filesystem files)
11 
*/
12 
 
13 
template <class Ty>
14 
class x2buffer : public mystream::basic_buffer<Ty>
15 
{
16 
	private:
17 
		static const size_t buffer_size=5000;
18 
 
19 
		X2FILE m_hFile;
20 
		unsigned char m_buffer[buffer_size];
21 
		unsigned char *m_bufferPos;
22 
		unsigned char *m_bufferEnd;
23 
 
24 
		bool m_bExternalHandle;
25 
 
26 
		size_t availBuffer() const { return m_bufferEnd - m_bufferPos; }
27 
 
28 
	public:
29 
		virtual operator bool() const { return m_hFile!=0; }
30 
		virtual bool eof() const { return X2FD_EOF(m_hFile)!=0; }
31 
 
32 
		x2buffer()
33 
		{
34 
			m_hFile=0; m_bExternalHandle=false;
35 
			m_bufferPos=m_buffer; m_bufferEnd=m_buffer + buffer_size;
36 
		}
37 
 
38 
		~x2buffer() { close(); }
39 
 
40 
		bool open(const char *fileName, mystream::filestream_base::OpenMode m)
41 
		{
42 
			return false;
43 
		}
44 
 
45 
		void changeSize() { X2FD_SetEndOfFile(m_hFile); }
46 
 
47 
		bool open(X2FILE hFile)
48 
		{
49 
			close();
50 
			m_hFile=hFile;
51 
			m_bExternalHandle=true;
52 
			return hFile!=0;
53 
		}
54 
 
55 
		virtual void close()
56 
		{
57 
			if(m_hFile){
58 
				flush();
59 
				X2FD_SetEndOfFile(m_hFile);
60 
				if(m_bExternalHandle==false)
61 
					X2FD_CloseFile(m_hFile);
62 
				m_hFile=0;
63 
				m_bExternalHandle=false;
64 
			}
65 
		}
66 
 
67 
		bool flush()
68 
		{
69 
			size_t s=m_bufferPos - m_buffer;
70 
			if(s > 0){
71 
				if(X2FD_WriteFile(m_hFile, m_buffer, (unsigned int)s)!=(unsigned int)s)
72 
					return false;
73 
				m_bufferPos=m_buffer;
74 
			}
75 
			return true;
76 
		}
77 
 
78 
		virtual size_type read(value_type_ptr buffer, size_type size) { return -1; }
79 
 
80 
		virtual size_type write(const_value_type_ptr data, size_type size)
81 
		{
82 
			size_type res=0;
83 
			if(size > availBuffer())
84 
				flush();
85 
 
86 
			if(size > availBuffer()){
87 
				res=X2FD_WriteFile(m_hFile, data, (unsigned int)size);
88 
			}
89 
			else{
90 
				memcpy(m_bufferPos, data, size);
91 
				m_bufferPos+=size;
92 
				res=size;
93 
			}
94 
			return res;
95 
		}
96 
 
97 
		virtual size_type tellp() const { return tellg(); }
98 
		virtual size_type tellg() const { return X2FD_FileTell(m_hFile); }
99 
		virtual size_type seekp(int offset, mystream::stream_base::seek_type origin) { return seekg(offset, origin); }
100 
		virtual size_type seekg(int offset, mystream::stream_base::seek_type origin)
101 
		{
102 
			int o;
103 
			size_t res;
104 
			flush();
105 
 
106 
			switch(origin){
107 
				case mystream::stream_base::seek_begin:
108 
					o=X2FD_SEEK_SET;
109 
					break;
110 
				case mystream::stream_base::seek_end:
111 
					o=X2FD_SEEK_END;
112 
					break;
113 
				case mystream::stream_base::seek_current:
114 
					o=X2FD_SEEK_CUR;
115 
					break;
116 
				default:
117 
					o=-1;
118 
			}
119 
			if(o!=-1)
120 
				res=X2FD_SeekFile(m_hFile, offset, o);
121 
			else
122 
				res=0;
123 
 
124 
			return res;
125 
		}
126 
};
127 
 
128 
/*
129 
	doesn't work with new mystream::stream stuff
130 
 
131 
	change mystream::file_stream to be indenpedent (move open to buffer)
132 
 
133 
	change ox2filestream to be buffer for mystream::file_stream
134 
 
135 
	otextX2file = file_stream<stream<char>, x2buffer<char> >
136 
*/
137 
 
138 
// these 2 lines added just to lessen number of errors
139 
//typedef mystream::stream<unsigned char *> obinaryfilestream;
140 
//typedef mystream::stream<char *> otextfilestream;
141 
 
142 
typedef mystream::stream<unsigned char> obinaryfilestream;
143 
typedef mystream::stream<char> otextfilestream;
144 
 
145 
typedef mystream::file_stream<obinaryfilestream, x2buffer<char> > obinaryX2file;
146 
//typedef mystream::file_stream<otextfilestream, x2buffer<char> > otextX2file;
147 
 
148 
class otextX2file : public mystream::file_stream<otextfilestream, x2buffer<char> >
149 
{
150 
	private:
151 
 
152 
	public:
153 
		typedef mystream::file_stream<otextfilestream, x2buffer<char> > base;
154 
 
155 
		bool open(X2FILE hFile)
156 
		{
157 
			bool res=m_buffer.open(hFile);
158 
			clear();
159 
			return res;
160 
		}
161 
};
162 
 
163 
inline
164 
otextfilestream& operator << (otextfilestream& os, const char *str)
165 
{
166 
	os.write(str, strlen(str));
167 
	return os;
168 
}
169 
 
170 
inline
171 
otextfilestream& operator << (otextfilestream& os, char ch)
172 
{
173 
	os.write(&ch, 1);
174 
	return os;
175 
}
176 
 
177 
inline
178 
otextfilestream& operator << (otextfilestream& os, int i)
179 
{
180 
	static char buff[20];
181 
	itoa(i, buff, 10);
182 
	os << buff;
183 
	return os;
184 
}
185 
 
186 
inline
187 
otextfilestream& endl(otextfilestream& os)
188 
{
189 
	os.write("\r\n", 2);
190 
	return os;
191 
}
192 
 
193 
inline
194 
otextfilestream& operator << (otextfilestream& os, otextfilestream& f(otextfilestream& os))
195 
{
196 
	return f(os);
197 
}
198 
 
199 
template <class Ty>
200 
otextfilestream& operator << (otextfilestream& os, Ty &o)
201 
{
202 
	o.toFile(os);
203 
	return os;
204 
}
205 
 
206 
#endif // !defined(BOB_X2FILE_STREAM_INCLUDED)