OpenStructure
converting_streams.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // This file is part of the OpenStructure project <www.openstructure.org>
3 //
4 // Copyright (C) 2008-2011 by the OpenStructure authors
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License as published by the Free
8 // Software Foundation; either version 3.0 of the License, or (at your option)
9 // any later version.
10 // This library is distributed in the hope that it will be useful, but WITHOUT
11 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
13 // details.
14 //
15 // You should have received a copy of the GNU Lesser General Public License
16 // along with this library; if not, write to the Free Software Foundation, Inc.,
17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 //------------------------------------------------------------------------------
19 
20 #ifndef OST_IO_CONVERTING_STREAMS_H
21 #define OST_IO_CONVERTING_STREAMS_H
22 
23 #include <iostream>
24 #include "convert.hh"
25 
26 #include <ost/stdint.hh>
27 #include <ost/config.hh>
28 
29 
30 namespace ost { namespace io {
31 
32 
33 template<int CONVERSIONTYPE>
34 class BinaryOStream : public std::basic_ostream<char>
35 {
36 public:
37  BinaryOStream(std::basic_ostream<char>& ostr):
38  std::basic_ostream<char>(ostr.rdbuf())
39  {
40  }
41 
42  BinaryOStream& operator<<(const char& value)
43  {
45  return *this;
46  }
48  {
49  return write_helper(&value,1);
50  }
52  {
53  return write_helper(&value,1);
54  }
56  {
57  return write_helper(&value,1);
58  }
60  {
61  return write_helper(&value,1);
62  }
64  {
65  return write_helper(&value,1);
66  }
68  {
69  return write_helper(&value,1);
70  }
72  {
73  return write_helper(&value,1);
74  }
76  {
77  return write_helper(&value,1);
78  }
79  BinaryOStream& operator<<(const float& value)
80  {
81  return write_helper(&value,1);
82  }
83  BinaryOStream& operator<<(const double& value)
84  {
85  return write_helper(&value,1);
86  }
87 
88  BinaryOStream& write(const char* value,std::streamsize n)
89  {
91  return *this;
92  }
93  BinaryOStream& write(const int8_t* value,std::streamsize n)
94  {
95  return write_helper(value,n);
96  }
97  BinaryOStream& write(const uint8_t* value,std::streamsize n)
98  {
99  return write_helper(value,n);
100  }
101  BinaryOStream& write(const int16_t* value,std::streamsize n)
102  {
103  return write_helper(value,n);
104  }
105  BinaryOStream& write(const uint16_t* value,std::streamsize n)
106  {
107  return write_helper(value,n);
108  }
109  BinaryOStream& write(const int32_t* value,std::streamsize n)
110  {
111  return write_helper(value,n);
112  }
113  BinaryOStream& write(const uint32_t* value,std::streamsize n)
114  {
115  return write_helper(value,n);
116  }
117  BinaryOStream& write(const int64_t* value,std::streamsize n)
118  {
119  return write_helper(value,n);
120  }
121  BinaryOStream& write(const uint64_t* value,std::streamsize n)
122  {
123  return write_helper(value,n);
124  }
125  BinaryOStream& write(const float* value,std::streamsize n)
126  {
127  return write_helper(value,n);
128  }
129 
130  BinaryOStream& write(const double* value,std::streamsize n)
131  {
132  return write_helper(value,n);
133  }
134 
135 protected:
136  template<typename T>
137  BinaryOStream& write_helper(const T* value,std::streamsize n)
138  {
139  for(std::streamsize i=0;i<n;++i){
140  T tmp=Convert<CONVERSIONTYPE,T>::To(value[i]);
141  std::basic_ostream<char>::write(reinterpret_cast<char*>(&tmp),sizeof(T));
142  }
143  return *this;
144  }
145 
146 };
147 
148 template<int CONVERSIONTYPE>
149 class BinaryIStream : public std::basic_istream<char>
150 {
151 public:
152  BinaryIStream( std::basic_istream<char>& istr):
153  std::basic_istream<char>(istr.rdbuf())
154  {
155  }
156 
158  {
159  return read_helper(&value,1);
160  }
162  {
163  return read_helper(&value,1);
164  }
166  {
167  return read_helper(&value,1);
168  }
170  {
171  return read_helper(&value,1);
172  }
174  {
175  return read_helper(&value,1);
176  }
178  {
179  return read_helper(&value,1);
180  }
182  {
183  return read_helper(&value,1);
184  }
186  {
187  return read_helper(&value,1);
188  }
189  BinaryIStream& operator>>(float& value)
190  {
191  return read_helper(&value,1);
192  }
193  BinaryIStream& operator>>(double& value)
194  {
195  return read_helper(&value,1);
196  }
197 
198  BinaryIStream& read(char* value,std::streamsize n)
199  {
201  return *this;
202  }
203  BinaryIStream& read(uint8_t* value,std::streamsize n)
204  {
205  return read_helper(value,n);
206  }
207  BinaryIStream& read(int16_t* value,std::streamsize n)
208  {
209  return read_helper(value,n);
210  }
211  BinaryIStream& read(uint16_t* value,std::streamsize n)
212  {
213  return read_helper(value,n);
214  }
215  BinaryIStream& read(int32_t* value,std::streamsize n)
216  {
217  return read_helper(value,n);
218  }
219  BinaryIStream& read(uint32_t* value,std::streamsize n)
220  {
221  return read_helper(value,n);
222  }
223  BinaryIStream& read(int64_t* value,std::streamsize n)
224  {
225  return read_helper(value,n);
226  }
227  BinaryIStream& read(uint64_t* value,std::streamsize n)
228  {
229  return read_helper(value,n);
230  }
231  BinaryIStream& read(float* value,std::streamsize n)
232  {
233  return read_helper(value,n);
234  }
235  BinaryIStream& read(double* value,std::streamsize n)
236  {
237  return read_helper(value,n);
238  }
239 
240 protected:
241  template<typename T>
242  BinaryIStream& read_helper(T* value,std::streamsize n)
243  {
244  std::basic_istream<char>::read(reinterpret_cast<char*>(value),n*sizeof(T));
245  for(std::streamsize i=0;i<n;++i){
247  }
248  return *this;
249  }
250 };
251 
252 
253 
254 } // io ns
255 
256 
257 
258 } // ost ns
259 
260 
261 #endif
262 
263