MPQC 2.3.1
mstate.h
1//
2// mstate.h
3//
4// Copyright (C) 1996 Limit Point Systems, Inc.
5//
6// Author: Curtis Janssen <cljanss@limitpt.com>
7// Maintainer: LPS
8//
9// This file is part of the SC Toolkit.
10//
11// The SC Toolkit is free software; you can redistribute it and/or modify
12// it under the terms of the GNU Library General Public License as published by
13// the Free Software Foundation; either version 2, or (at your option)
14// any later version.
15//
16// The SC Toolkit is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU Library General Public License for more details.
20//
21// You should have received a copy of the GNU Library General Public License
22// along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24//
25// The U.S. Government is granted a limited license as per AL 91-7.
26//
27
28#ifdef __GNUC__
29#pragma interface
30#endif
31
32#ifndef _util_group_mstate_h
33#define _util_group_mstate_h
34
35#include <util/state/state.h>
36#include <util/state/statein.h>
37#include <util/state/stateout.h>
38#include <util/group/message.h>
39
40namespace sc {
41
45class MsgStateSend: public StateOut {
46 private:
47 // do not allow copy constructor or assignment
48 MsgStateSend(const MsgStateSend&);
49 void operator=(const MsgStateSend&);
50 protected:
52 int nbuf; // the number of bytes used in the buffer
53 int bufsize; // the allocated size of the data buffer
54 char* buffer; // the data buffer
55 char* send_buffer; // the buffer used to send data (includes nbuf)
56 int nheader; // nbuf + nheader = the number of bytes in send_buffer to send
57 int* nbuf_buffer; // the pointer to the nbuf stored in the buffer
58
59 int put_array_void(const void*, int);
60 public:
61 MsgStateSend(const Ref<MessageGrp>&);
62 virtual ~MsgStateSend();
63
65 virtual void flush() = 0;
66
69 void set_buffer_size(int);
70
73 int put(const ClassDesc*);
74 int put(char r);
75 int put(unsigned int r);
76 int put(int r);
77 int put(float r);
78 int put(double r);
79 int put(const char*,int);
80 int put(const int*,int);
81 int put(const unsigned int*,int);
82 int put(const float*,int);
83 int put(const double*,int);
84};
85
89class MsgStateBufRecv: public StateIn {
90 private:
91 // do not allow copy constructor or assignment
92 MsgStateBufRecv(const MsgStateBufRecv&);
93 void operator=(const MsgStateBufRecv&);
94 protected:
96 int nbuf; // the number of bytes used in the buffer
97 int ibuf; // the current pointer withing the buffer
98 int bufsize; // the allocated size of the buffer
99 char* buffer; // the data buffer
100 char* send_buffer; // the buffer used to send data (includes nbuf)
101 int nheader; // nbuf + nheader = the number of bytes in send_buffer to send
102 int* nbuf_buffer; // the pointer to the nbuf stored in the buffer
103
104 int get_array_void(void*,int);
105
107 virtual void next_buffer() = 0;
108 public:
113
114 virtual ~MsgStateBufRecv();
115
119};
120
123class MsgStateRecv: public MsgStateBufRecv {
124 private:
125 // do not allow copy constructor or assignment
126 MsgStateRecv(const MsgStateRecv&);
127 void operator=(const MsgStateRecv&);
128 public:
131
132 virtual ~MsgStateRecv();
133
137 int version(const ClassDesc*);
138
141 int get(const ClassDesc**);
142 int get(char&r, const char *key = 0);
143 int get(unsigned int&r, const char *key = 0);
144 int get(int&r, const char *key = 0);
145 int get(float&r, const char *key = 0);
146 int get(double&r, const char *key = 0);
147 int get(char*&);
148 int get(unsigned int*&);
149 int get(int*&);
150 int get(float*&);
151 int get(double*&);
152};
153
157class StateSend: public MsgStateSend {
158 private:
159 // do not allow copy constructor or assignment
160 StateSend(const StateSend&);
161 void operator=(const StateSend&);
162 private:
163 int target_;
164 public:
167
168 ~StateSend();
170 void target(int);
172 void flush();
173};
174
178class StateRecv: public MsgStateRecv {
179 private:
180 // do not allow copy constructor or assignment
181 StateRecv(const StateRecv&);
182 void operator=(const StateRecv&);
183 private:
184 int source_;
185 protected:
187 public:
191 void source(int);
192};
193
197class BcastStateSend: public MsgStateSend {
198 private:
199 // do not allow copy constructor or assignment
200 BcastStateSend(const BcastStateSend&);
201 void operator=(const BcastStateSend&);
202 public:
205
206 ~BcastStateSend();
208 void flush();
209};
210
214class BcastStateRecv: public MsgStateRecv {
215 private:
216 // do not allow copy constructor or assignment
217 BcastStateRecv(const BcastStateRecv&);
218 void operator=(const BcastStateRecv&);
219 protected:
220 int source_;
222 public:
226 void source(int s);
227};
228
233 private:
234 BcastStateRecv *recv_;
235 BcastStateSend *send_;
236 public:
238 BcastState(const Ref<MessageGrp> &, int source = 0);
239
240 ~BcastState();
241
245 void bcast(int &);
246 void bcast(double &);
247 void bcast(int *&, int);
248 void bcast(double *&, int);
249 template <class T> void bcast(Ref<T>&a)
250 {
251 if (recv_) {
252 a << SavableState::restore_state(*recv_);
253 }
254 else if (send_) {
256 }
257 }
258
261 void flush();
262
266
269};
270
274class BcastStateInBin: public MsgStateBufRecv {
275 private:
276 // do not allow copy constructor or assignment
277 BcastStateInBin(const BcastStateRecv&);
278 void operator=(const BcastStateRecv&);
279 protected:
280 int opened_;
281 int file_position_;
282 std::streambuf *buf_;
283
285 int get_array_void(void*, int);
286 public:
290 BcastStateInBin(const Ref<MessageGrp>&, const char *filename);
291
292 ~BcastStateInBin();
293
294 virtual int open(const char *name);
295 virtual void close();
296
297 void seek(int loc);
298 int seekable();
299 int tell();
301};
302
303}
304
305#endif
306
307// Local Variables:
308// mode: c++
309// c-file-style: "CLJ"
310// End:
void seek(int loc)
Set the current position in the file.
int use_directory()
Returns true of this object uses a directory.
BcastStateInBin(const Ref< KeyVal > &)
Create the BcastStateRecv using the default MessageGrp.
int seekable()
Return non-zero if seek does anything sensible.
void next_buffer()
Specializations must implement next_buffer().
int tell()
Return the current position in the file.
BcastStateInBin(const Ref< MessageGrp > &, const char *filename)
Create the BcastStateRecv.
BcastStateRecv does the receive part of a broadcast of an object to all nodes.
Definition mstate.h:214
BcastStateRecv(const Ref< MessageGrp > &, int source=0)
Create the BcastStateRecv.
void next_buffer()
Specializations must implement next_buffer().
void source(int s)
Set the source node.
BcastStateSend does the send part of a broadcast of an object to all nodes.
Definition mstate.h:197
void flush()
Flush the data remaining in the buffer.
BcastStateSend(const Ref< MessageGrp > &)
Create the BcastStateSend.
void flush()
Force data to be written.
void forget_references()
Call the StateOut or StateIn forget_references member.
void bcast(int &)
Broadcast data to all nodes.
void set_buffer_size(int)
Controls the amount of data that is buffered before it is sent.
BcastState(const Ref< MessageGrp > &, int source=0)
Create a BcastState object. The default source is node 0.
This class is used to contain information about classes.
Definition class.h:158
virtual void next_buffer()=0
Specializations must implement next_buffer().
MsgStateBufRecv(const Ref< MessageGrp > &)
MsgStateBufRecv can be initialized with a MessageGrp.
void set_buffer_size(int)
The buffer size of statein and stateout objects that communicate with each other must match.
MsgStateBufRecv()
Use the default MessageGrp.
int get(char *&)
These restore data saved with StateOut's put.
MsgStateRecv(const Ref< MessageGrp > &)
MsgStateRecv must be initialized with a MessageGrp.
int version(const ClassDesc *)
Returns the version of the ClassDesc.
int get(char &r, const char *key=0)
These restore data saved with StateOut's put. members.
int get(const ClassDesc **)
I only need to override get(ClassDesc**) but C++ will hide all of the other get's so I must override ...
int put(const char *, int)
Write the given array data.
int put(char r)
Write the given datum.
void set_buffer_size(int)
The buffer size of statein and stateout objects that communicate with each other must match.
virtual void flush()=0
Specializations must implement flush().
int put(const ClassDesc *)
I only need to override put(const ClassDesc*) but C++ will hide all of the other put's so I must over...
A template class that maintains references counts.
Definition ref.h:332
T * pointer() const
Returns a pointer the reference counted object.
Definition ref.h:383
static SavableState * restore_state(StateIn &si)
Restores objects saved with save_state.
void save_state(StateOut &)
Save the state of the object as specified by the StateOut object.
void source(int)
Specify the source node.
StateRecv(const Ref< MessageGrp > &)
Create a StateRecv given a MessageGrp.
void next_buffer()
Specializations must implement next_buffer().
void flush()
Flush the buffer.
StateSend(const Ref< MessageGrp > &)
Create a StateSend given a MessageGrp.
void target(int)
Specify the target node.

Generated at Sun Jan 19 2025 00:00:00 for MPQC 2.3.1 using the documentation package Doxygen 1.13.2.