00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifdef __GNUC__
00029 #pragma interface
00030 #endif
00031
00032 #ifndef _util_group_mstate_h
00033 #define _util_group_mstate_h
00034
00035 #include <util/state/state.h>
00036 #include <util/state/statein.h>
00037 #include <util/state/stateout.h>
00038 #include <util/group/message.h>
00039
00040 namespace sc {
00041
00045 class MsgStateSend: public StateOut {
00046 private:
00047
00048 MsgStateSend(const MsgStateSend&);
00049 void operator=(const MsgStateSend&);
00050 protected:
00051 Ref<MessageGrp> grp;
00052 int nbuf;
00053 int bufsize;
00054 char* buffer;
00055 char* send_buffer;
00056 int nheader;
00057 int* nbuf_buffer;
00058
00059 int put_array_void(const void*, int);
00060 public:
00061 MsgStateSend(const Ref<MessageGrp>&);
00062 virtual ~MsgStateSend();
00063
00065 virtual void flush() = 0;
00066
00069 void set_buffer_size(int);
00070
00073 int put(const ClassDesc*);
00074 int put(char r);
00075 int put(unsigned int r);
00076 int put(int r);
00077 int put(float r);
00078 int put(double r);
00079 int put(const char*,int);
00080 int put(const int*,int);
00081 int put(const unsigned int*,int);
00082 int put(const float*,int);
00083 int put(const double*,int);
00084 };
00085
00089 class MsgStateBufRecv: public StateIn {
00090 private:
00091
00092 MsgStateBufRecv(const MsgStateBufRecv&);
00093 void operator=(const MsgStateBufRecv&);
00094 protected:
00095 Ref<MessageGrp> grp;
00096 int nbuf;
00097 int ibuf;
00098 int bufsize;
00099 char* buffer;
00100 char* send_buffer;
00101 int nheader;
00102 int* nbuf_buffer;
00103
00104 int get_array_void(void*,int);
00105
00107 virtual void next_buffer() = 0;
00108 public:
00110 MsgStateBufRecv(const Ref<MessageGrp>&);
00112 MsgStateBufRecv();
00113
00114 virtual ~MsgStateBufRecv();
00115
00118 void set_buffer_size(int);
00119 };
00120
00123 class MsgStateRecv: public MsgStateBufRecv {
00124 private:
00125
00126 MsgStateRecv(const MsgStateRecv&);
00127 void operator=(const MsgStateRecv&);
00128 public:
00130 MsgStateRecv(const Ref<MessageGrp>&);
00131
00132 virtual ~MsgStateRecv();
00133
00137 int version(const ClassDesc*);
00138
00141 int get(const ClassDesc**);
00142 int get(char&r, const char *key = 0);
00143 int get(unsigned int&r, const char *key = 0);
00144 int get(int&r, const char *key = 0);
00145 int get(float&r, const char *key = 0);
00146 int get(double&r, const char *key = 0);
00147 int get(char*&);
00148 int get(unsigned int*&);
00149 int get(int*&);
00150 int get(float*&);
00151 int get(double*&);
00152 };
00153
00157 class StateSend: public MsgStateSend {
00158 private:
00159
00160 StateSend(const StateSend&);
00161 void operator=(const StateSend&);
00162 private:
00163 int target_;
00164 public:
00166 StateSend(const Ref<MessageGrp>&);
00167
00168 ~StateSend();
00170 void target(int);
00172 void flush();
00173 };
00174
00178 class StateRecv: public MsgStateRecv {
00179 private:
00180
00181 StateRecv(const StateRecv&);
00182 void operator=(const StateRecv&);
00183 private:
00184 int source_;
00185 protected:
00186 void next_buffer();
00187 public:
00189 StateRecv(const Ref<MessageGrp>&);
00191 void source(int);
00192 };
00193
00197 class BcastStateSend: public MsgStateSend {
00198 private:
00199
00200 BcastStateSend(const BcastStateSend&);
00201 void operator=(const BcastStateSend&);
00202 public:
00204 BcastStateSend(const Ref<MessageGrp>&);
00205
00206 ~BcastStateSend();
00208 void flush();
00209 };
00210
00214 class BcastStateRecv: public MsgStateRecv {
00215 private:
00216
00217 BcastStateRecv(const BcastStateRecv&);
00218 void operator=(const BcastStateRecv&);
00219 protected:
00220 int source_;
00221 void next_buffer();
00222 public:
00224 BcastStateRecv(const Ref<MessageGrp>&, int source = 0);
00226 void source(int s);
00227 };
00228
00232 class BcastState {
00233 private:
00234 BcastStateRecv *recv_;
00235 BcastStateSend *send_;
00236 public:
00238 BcastState(const Ref<MessageGrp> &, int source = 0);
00239
00240 ~BcastState();
00241
00245 void bcast(int &);
00246 void bcast(double &);
00247 void bcast(int *&, int);
00248 void bcast(double *&, int);
00249 template <class T> void bcast(Ref<T>&a)
00250 {
00251 if (recv_) {
00252 a << SavableState::restore_state(*recv_);
00253 }
00254 else if (send_) {
00255 SavableState::save_state(a.pointer(),*send_);
00256 }
00257 }
00258
00261 void flush();
00262
00265 void forget_references();
00266
00268 void set_buffer_size(int);
00269 };
00270
00274 class BcastStateInBin: public MsgStateBufRecv {
00275 private:
00276
00277 BcastStateInBin(const BcastStateRecv&);
00278 void operator=(const BcastStateRecv&);
00279 protected:
00280 int opened_;
00281 int file_position_;
00282 std::streambuf *buf_;
00283
00284 void next_buffer();
00285 int get_array_void(void*, int);
00286 public:
00288 BcastStateInBin(const Ref<KeyVal> &);
00290 BcastStateInBin(const Ref<MessageGrp>&, const char *filename);
00291
00292 ~BcastStateInBin();
00293
00294 virtual int open(const char *name);
00295 virtual void close();
00296
00297 void seek(int loc);
00298 int seekable();
00299 int tell();
00300 int use_directory();
00301 };
00302
00303 }
00304
00305 #endif
00306
00307
00308
00309
00310