MarshaledObj.h
Go to the documentation of this file.
1  /**********************************************************************
2  * Include file with Base Class of Marshalgen *
3  **********************************************************************/
4 
5 #ifndef MARSHALEDOBJ_H
6 #define MARSHALEDOBJ_H
7 
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <assert.h>
12 
13 #define MSH_ASSERT(X) {assert(X);}
14 
15 #define MSH_HEADER_SIZE (sizeof(int)*2)
16 // the first field (first sizeof(int) bytes) contains the $TYPE_CHOICE
17 // the second field contains the size including the header
18 #define MSH_TOTALSIZE_OFFSET (sizeof(int))
19 #define MSH_TYPECHOICE_OFFSET 0
20 
21 #define MSH_SET_TYPECHOICE(X) { memcpy(msh_buffer+MSH_TYPECHOICE_OFFSET,&(X),sizeof(int));}
22 #define MSH_SET_TOTALSIZE(X) { memcpy(msh_buffer+MSH_TOTALSIZE_OFFSET,&(X),sizeof(int));}
23 #define MSH_GET_TYPECHOICE(X,BUF) { memcpy(&(X), ((char*)BUF)+MSH_TYPECHOICE_OFFSET,sizeof(int));}
24 #define MSH_GET_TOTALSIZE(X,BUF) { memcpy(&(X), ((char*)BUF)+MSH_TOTALSIZE_OFFSET,sizeof(int));}
25 
26 
27 class MarshaledObj {
28  private:
29  // Make sure all marshaled objects are word aligned.
30  static const int WORD_SIZE = sizeof(long);
31  public:
32  static int ROUND_UP( int x ){
33  return (((x)+(WORD_SIZE-1)) / WORD_SIZE) * WORD_SIZE;
34  }
35 
36  public:
37  // Constructs an empty MarshaledObj,
39  msh_extent = 128;
41  msh_isUnmarshalDone = false;
42 
43  msh_buffer = (char *)malloc(msh_extent);
45 
48 
49  msh_typechoice = 0;
50  int totalsize = msh_cursor-msh_buffer;
51 
53  MSH_SET_TOTALSIZE(totalsize);
54  }
55 
56  //MarshaledObj(void *buf);
57  // This constructs a MarshledObj from a buffer (of type char*) for unmarshaling.
58  // buf is obtain from an already marshaled object.
59  // The first field of buf must be an int that contains the size of the buf
60  // NOT including itself.
61  // isUnmarshaling must be 'u' (for unmarshaling) .
62  MarshaledObj(void *buf, char chIsUnmarshaling) {
63  msh_isUnmarshalDone = false;
64 
65  if(chIsUnmarshaling != 'u') {
66  printf("MarshaledObj(void*, char): wrong argument\n");
67  return;
68  }
69 
70  //msh_extent = ROUND_UP(*(int *)buf + sizeof(int));
72 
75 
76  msh_buffer = (char *)malloc(msh_extent);
78 
79  memcpy(msh_buffer, (char *)buf, msh_extent);
82 
83  //MSH_SET_TYPECHOICE(msh_typechoice);
84 
85  }
86 
88  if ( ! isUnmarshaling() )
89  free(msh_buffer);
90  }
91 
92  inline bool isUnmarshaling() {
93  return (msh_extent <= 0);
94  }
95 
96  private:
97  // Dont use copy constructor
99 
100  protected:
101  int msh_typechoice; // alias of $TYPE_CHOICE
102 
103  // points to the buffer (header+body)
104  char *msh_buffer;
105 
106  // msh_field_begin points to the size of the current field being marshaled
108 
109  // msh_size contains the total size of msh_buffer. i.e.,
110  size_t msh_size;
111 
112  // msh_cursor points to the next field to be marshaled.
113  char *msh_cursor;
114 
115  // msh_extent is the total allocated space for msh_buffer.
116  // msh_extent is always >= msh_size
117  size_t msh_extent;
118 
119  bool msh_isUnmarshalDone; //Is unmarshaling done yet?
120 
121  public:
122  inline void EXTEND_BUFFER(int size){
123  msh_size += size;
124  if(msh_size > msh_extent){
125  resizeBuffer(msh_size);
126  }
127  }
128 
129  void resizeBuffer(size_t new_size ) {
130  int msh_displacement = msh_cursor - msh_buffer;
131  int field_displacement = msh_field_begin - msh_buffer;
132 
133  while(new_size > msh_extent)
134  msh_extent *= 2;
135 
136  msh_buffer = (char *)realloc( msh_buffer, msh_extent);
137  MSH_ASSERT(msh_buffer);
138 
139  msh_cursor = msh_buffer + msh_displacement;
140  msh_field_begin = msh_buffer + field_displacement;
141  }
142 
143  public:
144  // Returns the total size of buffer
145  inline int getBufferSize() {
146  return msh_size;
147  }
148 
149  inline char *getBuffer() {
150  return msh_buffer;
151  }
152 
153  /* p: pointer to the data field, size: size of that primitive data field */
154  void marshalPrimitive(void* p, int size) {
155  int msh_currentSize;
156  if (isUnmarshaling())
157  throw "Tried to marshal in object marked isUnmarshaling = true";
158  msh_currentSize = size;
159  EXTEND_BUFFER(msh_currentSize + sizeof(int));
160 
161  // *(int *)msh_cursor = msh_currentSize;
162  memcpy(msh_cursor, &msh_currentSize, sizeof(int));
163  msh_cursor += sizeof(int);
164  memcpy(msh_cursor, p, size);
165  msh_cursor += msh_currentSize;
166  msh_size = msh_cursor - msh_buffer;
167 
168  MSH_SET_TOTALSIZE(msh_size);
169  }
170 
171  void unmarshalPrimitive(void* p, int size) {
172  int msh_currentSize;
173  //memcpy(&msh_currentSize, msh_cursor, sizeof(int));
174  /* in case *msh_cursor is invalid, use "size" not to crash the memory */
175  msh_currentSize = size;
176  msh_cursor += sizeof(int);
177  memcpy(p, msh_cursor, msh_currentSize);
178  msh_cursor += msh_currentSize;
179  //msh_size = msh_cursor - msh_buffer;
180  }
181 };
182 
183 /* Used for distinguish the class types of the template parameter
184  vietha 2003.05.01 */
185 template <class T,class>
187 {
188 public:
189  enum {Is = 0};
190 };
191 
192 template<class T>
194 {
195 public:
196  enum {Is = 1};
197 };
198 
199 #endif
const MarshaledObj & operator=(const MarshaledObj &right)
constexpr auto const & right(const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)
Definition: AssnsIter.h:112
bool isUnmarshaling()
Definition: MarshaledObj.h:92
MarshaledObj(void *buf, char chIsUnmarshaling)
Definition: MarshaledObj.h:62
bool msh_isUnmarshalDone
Definition: MarshaledObj.h:119
const char * p
Definition: xmltok.h:285
static const int WORD_SIZE
Definition: MarshaledObj.h:30
#define MSH_SET_TOTALSIZE(X)
Definition: MarshaledObj.h:22
#define MSH_GET_TYPECHOICE(X, BUF)
Definition: MarshaledObj.h:23
size_t msh_size
Definition: MarshaledObj.h:110
int getBufferSize()
Definition: MarshaledObj.h:145
void resizeBuffer(size_t new_size)
Definition: MarshaledObj.h:129
#define MSH_SET_TYPECHOICE(X)
Definition: MarshaledObj.h:21
#define MSH_ASSERT(X)
Definition: MarshaledObj.h:13
printf("%d Experimental points found\n", nlines)
char * msh_field_begin
Definition: MarshaledObj.h:107
void unmarshalPrimitive(void *p, int size)
Definition: MarshaledObj.h:171
static int ROUND_UP(int x)
Definition: MarshaledObj.h:32
void marshalPrimitive(void *p, int size)
Definition: MarshaledObj.h:154
char * msh_buffer
Definition: MarshaledObj.h:104
#define MSH_HEADER_SIZE
Definition: MarshaledObj.h:15
void EXTEND_BUFFER(int size)
Definition: MarshaledObj.h:122
size_t msh_extent
Definition: MarshaledObj.h:117
double T
Definition: Xdiff_gwt.C:5
char * msh_cursor
Definition: MarshaledObj.h:113
char * getBuffer()
Definition: MarshaledObj.h:149
#define MSH_GET_TOTALSIZE(X, BUF)
Definition: MarshaledObj.h:24