00001 #ifndef __SERIALIZESTREAM_H__
00002 #define __SERIALIZESTREAM_H__
00003
00004 #include "../io/IOClient.h"
00005
00006 namespace oasys {
00007
00008
00013 class SerializeStream {
00014 public:
00015 virtual ~SerializeStream() {}
00016
00018 int process_bits(const char* buf, size_t size) {
00019 return process_bits(const_cast<char*>(buf), size);
00020 }
00021
00027 virtual int process_bits(char* buf, size_t size) = 0;
00028 };
00029
00030
00031
00035 template<typename _Copy>
00036 class MemoryStream : public SerializeStream {
00037 public:
00038 MemoryStream(const char* buf, size_t size)
00039 : buf_(const_cast<char*>(buf)),
00040 size_(size), pos_(0) {}
00041
00042 virtual ~MemoryStream() {}
00043
00045 int process_bits(char* buf, size_t size) {
00046 if (pos_ + size > size_) {
00047 return -1;
00048 }
00049 _Copy::op(buf, buf_ + pos_, size);
00050 pos_ += size;
00051
00052 return size;
00053 }
00054
00055 private:
00056 char* buf_;
00057 size_t size_;
00058 size_t pos_;
00059 };
00060
00061
00062
00063 template<typename _IO_Op>
00064 class IOStream : public SerializeStream {
00065 public:
00066 IOStream(IOClient* io) : io_(io) {}
00067
00068 virtual ~IOStream() {}
00069
00071 int process_bits(char* buf, size_t size) {
00072 return _IO_Op::op(io_, buf, size);
00073 }
00074
00075 private:
00076 IOClient* io_;
00077 };
00078
00079
00080
00081 namespace StreamOps {
00082
00083 struct CopyTo {
00084 static void* op(void* dest, void* src, size_t n) {
00085 return memcpy(dest, src, n);
00086 }
00087 };
00088 struct CopyFrom {
00089 static void* op(void* src, void* dest, size_t n) {
00090 return memcpy(dest, src, n);
00091 }
00092 };
00093
00094 struct Read {
00095 static int op(IOClient* io, char* buf, size_t size) {
00096 return io->readall(buf, size);
00097 }
00098 };
00099
00100 struct Write {
00101 static int op(IOClient* io, char* buf, size_t size) {
00102 return io->readall(buf, size);
00103 }
00104 };
00105
00106 }
00107
00108 typedef MemoryStream<StreamOps::CopyTo> ReadMemoryStream;
00109 typedef MemoryStream<StreamOps::CopyFrom> WriteMemoryStream;
00110 typedef IOStream<StreamOps::Read> ReadIOStream;
00111 typedef IOStream<StreamOps::Write> WriteIOStream;
00112
00113
00114
00115 class WriteBase64Stream : public SerializeStream {
00116 public:
00117 WriteBase64Stream(SerializeStream* stream);
00118
00119 int process_bits(char* buf, size_t size);
00120
00121 private:
00122 SerializeStream* stream_;
00123 };
00124
00125 }
00126
00127 #endif