src/xtl/vobjio.h

   1 /*
   2  * Run-time polymorphic streams for XTL
   3  *
   4  * Copyright (C) 1998-2000 Jose' Orlando Pereira, jop@di.uminho.pt
   5  */
   6 /* XTL - eXternalization Template Library - http://gsd.di.uminho.pt/~jop/xtl
   7  * Copyright (C) 1998-2000 Jose' Orlando Pereira, Universidade do Minho
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the Free
  21  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  22  * MA 02111-1307, USA
  23  *
  24  * Id: vobjio.h 1.12 Fri, 05 May 2000 18:57:58 +0100 jop
  25  */
  26
  27 #ifndef __XTL_VOBJIO
  28 #define __XTL_VOBJIO
  29
  30 class v_buffer {
  31  public:
  32         virtual void read(char* ptr, int size)=0;
  33         virtual void write(char const* ptr, int size)=0;
  34
  35         virtual void* require(int size)=0;
  36         virtual void flush()=0;
  37 };
  38
  39 template <class Buffer>
  40 class v_buffer_wrap: public v_buffer {
  41  protected:
  42         Buffer buf;
  43
  44  public:
  45         virtual void read(char* ptr, int size) {buf.read(ptr, size);}
  46         virtual void write(char const* ptr, int size) {buf.write(ptr, size);}
  47
  48         virtual void* require(int size) {return buf.require(size);}
  49         virtual void flush() {buf.flush();}
  50 };
  51
  52 class v_mem_buffer: public v_buffer {
  53  private:
  54         mem_buffer buf;
  55
  56  public:
  57         v_mem_buffer(void *b, int size):buf(b, size) {}
  58
  59         virtual void read(char* ptr, int size) {buf.read(ptr, size);}
  60         virtual void write(char const* ptr, int size) {buf.write(ptr, size);}
  61
  62         virtual void* require(int size) {return buf.require(size);}
  63         virtual void flush() {buf.flush();}
  64 };
  65
  66 #define def_simple_input(type) \
  67         virtual void input_simple(type& data)=0;
  68
  69 #define def_simple_output(type) \
  70         virtual void output_simple(const type& data)=0;
  71
  72 class v_format {
  73  public:
  74         def_simple_input(bool)
  75         def_simple_input(char)
  76         def_simple_input(unsigned char)
  77         def_simple_input(short)
  78         def_simple_input(unsigned short)
  79         def_simple_input(int)
  80         def_simple_input(unsigned int)
  81         def_simple_input(long)
  82         def_simple_input(unsigned long)
  83         def_simple_input(longlong)
  84         def_simple_input(unsignedlonglong)
  85         def_simple_input(float)
  86         def_simple_input(double)
  87
  88         virtual void input_start()=0;
  89
  90         virtual void input_start_composite()=0;
  91         virtual void input_end_composite()=0;
  92
  93         virtual void input_start_vector()=0;
  94         virtual void input_end_vector()=0;
  95
  96         virtual void input_start_array(int& n)=0;
  97         virtual bool input_end_array(int& n)=0;
  98
  99         virtual void input_chars(char* data, int size)=0;
 100         virtual void input_raw(char* data, int size)=0;
 101
 102         def_simple_output(bool)
 103         def_simple_output(char)
 104         def_simple_output(unsigned char)
 105         def_simple_output(short)
 106         def_simple_output(unsigned short)
 107         def_simple_output(int)
 108         def_simple_output(unsigned int)
 109         def_simple_output(long)
 110         def_simple_output(unsigned long)
 111         def_simple_output(longlong)
 112         def_simple_output(unsignedlonglong)
 113         def_simple_output(float)
 114         def_simple_output(double)
 115
 116         virtual void output_start()=0;
 117
 118         virtual void output_start_composite()=0;
 119         virtual void output_end_composite()=0;
 120
 121         virtual void output_start_vector()=0;
 122         virtual void output_end_vector()=0;
 123
 124         virtual void output_start_array(int n)=0;
 125         virtual void output_end_array()=0;
 126
 127         virtual void output_chars(char const* data, int size)=0;
 128         virtual void output_raw(char const* data, int size)=0;
 129
 130         virtual void reset_buffer()=0;
 131 };
 132
 133 #undef def_simple_input
 134 #undef def_simple_output
 135
 136 #define def_simple_input(type) \
 137         virtual void input_simple(type& data) { \
 138                 rep.input_simple(data); \
 139         }
 140
 141 #define def_simple_output(type) \
 142         virtual void output_simple(const type& data) { \
 143                 rep.output_simple(data); \
 144         }
 145
 146 template <class Format>
 147 class v_format_wrap: public v_format {
 148  protected:
 149         Format rep;
 150
 151  public:
 152         typedef typename Format::buffer buffer;
 153
 154         v_format_wrap(buffer& buf):rep(buf) {}
 155
 156         def_simple_input(bool);
 157         def_simple_input(char);
 158         def_simple_input(unsigned char);
 159         def_simple_input(short);
 160         def_simple_input(unsigned short);
 161         def_simple_input(int);
 162         def_simple_input(unsigned int);
 163         def_simple_input(long);
 164         def_simple_input(unsigned long);
 165         def_simple_input(longlong);
 166         def_simple_input(unsignedlonglong);
 167         def_simple_input(float);
 168         def_simple_input(double);
 169
 170         virtual void input_start() {rep.input_start();}
 171
 172         virtual void input_start_composite() {rep.input_start_composite();}
 173         virtual void input_end_composite() {rep.input_end_composite();}
 174
 175         virtual void input_start_vector() {rep.input_start_vector();}
 176         virtual void input_end_vector() {rep.input_end_vector();}
 177
 178         virtual void input_start_array(int& n) {rep.input_start_array(n);}
 179         virtual bool input_end_array(int& n) {return rep.input_end_array(n);}
 180
 181         virtual void input_chars(char* data, int size) {rep.input_chars(data, size);}
 182         virtual void input_raw(char* data, int size) {rep.input_raw(data, size);}
 183
 184         def_simple_output(bool);
 185         def_simple_output(char);
 186         def_simple_output(unsigned char);
 187         def_simple_output(short);
 188         def_simple_output(unsigned short);
 189         def_simple_output(int);
 190         def_simple_output(unsigned int);
 191         def_simple_output(long);
 192         def_simple_output(unsigned long);
 193         def_simple_output(longlong);
 194         def_simple_output(unsignedlonglong);
 195         def_simple_output(float);
 196         def_simple_output(double);
 197
 198         virtual void output_start() {rep.output_start();}
 199
 200         virtual void output_start_composite() {rep.output_start_composite();}
 201         virtual void output_end_composite() {rep.output_end_composite();}
 202
 203         virtual void output_start_vector() {rep.output_start_vector();}
 204         virtual void output_end_vector() {rep.output_end_vector();}
 205
 206         virtual void output_start_array(int n) {rep.output_start_array(n);}
 207         virtual void output_end_array() {rep.output_end_array();}
 208
 209         virtual void output_chars(char const* data, int size) {rep.output_chars(data, size);}
 210         virtual void output_raw(char const* data, int size) {rep.output_raw(data, size);}
 211
 212         virtual void reset_buffer() { rep.reset_buffer(); }
 213 };
 214
 215 #undef def_simple_input
 216 #undef def_simple_output
 217
 218 #endif
 219