00001
00002 #ifndef _DATASERVER_REGISTER_H_
00003 #define _DATASERVER_REGISTER_H_
00004
00005 #include "dataserver.h"
00006
00007 #define REGISTER_DATA_BLOCK() int DataServer::RegisterExternal(char *keyword, RemoteSocket *C, int &error_flag, bool reg_flag)
00008
00009 #define REGISTER_VARIABLE(key,perm,data) {int ret = Register_Variable(C, error_flag, reg_flag, keyword, key, perm, data); if (ret) return ret;}
00010 #define REGISTER_STRUCTURE(key,perm,var) {int ret = Register_Structure(C, error_flag, reg_flag, keyword, key, perm, var); if (ret) return ret;}
00011
00012 #define REGISTER_1D_ARRAY(key,perm,data) {int ret = Register_Static_Array(C, error_flag, reg_flag, keyword, key, perm, data, data[0], sizeof(data), 1); if (ret) return ret;}
00013 #define REGISTER_2D_ARRAY(key,perm,data) {int ret = Register_Static_Array(C, error_flag, reg_flag, keyword, key, perm, data, data[0][0], sizeof(data), 2); if (ret) return ret;}
00014 #define REGISTER_3D_ARRAY(key,perm,data) {int ret = Register_Static_Array(C, error_flag, reg_flag, keyword, key, perm, data, data[0][0][0], sizeof(data), 3); if (ret) return ret;}
00015 #define REGISTER_4D_ARRAY(key,perm,data) {int ret = Register_Static_Array(C, error_flag, reg_flag, keyword, key, perm, data, data[0][0][0][0], sizeof(data), 4); if (ret) return ret;}
00016
00017 #define REGISTER_DYNAMIC_1D_ARRAY(key,perm, data, n1) {int ret = Register_Dynamic_1D_Array(C, error_flag, reg_flag, keyword, key, perm, data, n1); if (ret) return ret;}
00018 #define REGISTER_DYNAMIC_2D_ARRAY(key,perm, data, n1, n2) {int ret = Register_Dynamic_2D_Array(C, error_flag, reg_flag, keyword, key, perm, data, n1, n2); if (ret) return ret;}
00019 #define REGISTER_DYNAMIC_3D_ARRAY(key,perm, data, n1, n2, n3) {int ret = Register_Dynamic_3D_Array(C, error_flag, reg_flag, keyword, key, perm, data, n1, n2, n3); if (ret) return ret;}
00020 #define REGISTER_DYNAMIC_4D_ARRAY(key,perm, data, n1, n2, n3, n4) {int ret = Register_Dynamic_4D_Array(C, error_flag, reg_flag, keyword, key, perm, data, n1, n2, n3, n4); if (ret) return ret;}
00021
00022 inline bool gotWriteRequest(char *inpkey, char *key, char *perm)
00023 {
00024 char recvkey[80];
00025 sprintf(recvkey, "R%s", key);
00026 return (!strcmp(perm, "rw") && !strcmp(inpkey, recvkey));
00027 }
00028
00029 template <class Etype>
00030 inline int DataServer::Register_Variable(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype &data)
00031 {
00032 static int elemsize = sizeof(Etype);
00033 if (reg_flag)
00034 RegisterKey(key, VARIABLE, keyType(data), elemsize, 1, perm, &data);
00035
00036 if (!strcmp(inpkey, key))
00037 {
00038 flag = 0;
00039 Wait(key);
00040 C->SendVar(elemsize);
00041 C->SendVar(data);
00042 Post(key);
00043 return 1;
00044 }
00045 else if (gotWriteRequest(inpkey, key, perm))
00046 {
00047 flag = 2;
00048 Wait(key);
00049 C->SendVar(elemsize);
00050 C->RecvVar(&data);
00051 SetDirty(key);
00052 Post(key);
00053 return 1;
00054 }
00055 return 0;
00056 }
00057
00058 template <class Etype>
00059 inline int DataServer::Register_Structure(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype &data)
00060 {
00061 static int elemsize = sizeof(Etype);
00062 if (reg_flag)
00063 RegisterKey(key, CUSTOM_STRUCTURE, keyType(data), elemsize, 1, perm);
00064
00065 if (!strcmp(inpkey, key))
00066 {
00067 flag = 0;
00068 C->SendStruct(&data, Lock(key));
00069 return 1;
00070 }
00071 else if (gotWriteRequest(inpkey, key, perm))
00072 {
00073 flag = 2;
00074 C->RecvStruct(&data, Lock(key));
00075 SetDirty(key);
00076 return 1;
00077 }
00078 return 0;
00079 }
00080
00081 template <class Etype>
00082 inline int DataServer::Register_Static_Array(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, void *data, Etype &element, int totsize, int dim)
00083 {
00084 static int elemsize = sizeof(Etype);
00085 if (reg_flag)
00086 RegisterKey(key, (DataType) (STATIC_1D_ARRAY+dim-1), keyType(element), elemsize, totsize/elemsize, perm, &element);
00087
00088 if (!strcmp(inpkey, key))
00089 {
00090 flag = 0;
00091 Wait(key);
00092 C->SendVar(totsize);
00093 C->SendVar(elemsize);
00094 C->SendArrayGeneric(data, totsize, elemsize);
00095 Post(key);
00096 return 1;
00097 }
00098 else if (gotWriteRequest(inpkey, key, perm))
00099 {
00100 flag = 2;
00101 Wait(key);
00102 C->SendVar(totsize);
00103 C->SendVar(elemsize);
00104 C->RecvArrayGeneric(data, totsize, elemsize);
00105 SetDirty(key);
00106 Post(key);
00107 return 1;
00108 }
00109 return 0;
00110 }
00111
00112 template <class Etype>
00113 inline int DataServer::Register_Dynamic_1D_Array(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype *data, int &n1)
00114 {
00115 static int elemsize = sizeof(Etype);
00116 if (reg_flag)
00117 RegisterKey(key, DYNAMIC_1D_ARRAY, keyType(data[0]), elemsize, -1, perm);
00118 char varkey[80];
00119 sprintf(varkey, "%s_dim1", key);
00120 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n1)) return 1;
00121
00122 if (!strcmp(inpkey, key))
00123 {
00124 flag = 0;
00125 Wait(key);
00126 C->SendVar(n1);
00127 C->SendArray1D(data, n1);
00128 Post(key);
00129 return 1;
00130 }
00131 else if (gotWriteRequest(inpkey, key, perm))
00132 {
00133 flag = 2;
00134 Wait(key);
00135 C->SendVar(n1);
00136 C->RecvArray1D(data, n1);
00137 SetDirty(key);
00138 Post(key);
00139 return 1;
00140 }
00141 return 0;
00142 }
00143
00144 template <class Etype>
00145 inline int DataServer::Register_Dynamic_2D_Array(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype **data, int &n1, int &n2)
00146 {
00147 static int elemsize = sizeof(Etype);
00148 if (reg_flag)
00149 RegisterKey(key, DYNAMIC_2D_ARRAY, keyType(data[0][0]), elemsize, -1, perm);
00150
00151 char varkey[80];
00152 sprintf(varkey, "%s_dim1", key);
00153 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n1)) return 1;
00154 sprintf(varkey, "%s_dim2", key);
00155 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n2)) return 1;
00156
00157 if (!strcmp(inpkey, key))
00158 {
00159 flag = 0;
00160 Wait(key);
00161 C->SendVar(n1);
00162 C->SendVar(n2);
00163 C->SendArray2D(data, n1, n2);
00164 Post(key);
00165 return 1;
00166 }
00167 else if (gotWriteRequest(inpkey, key, perm))
00168 {
00169 flag = 2;
00170 Wait(key);
00171 C->SendVar(n1);
00172 C->SendVar(n2);
00173 C->RecvArray2D(data, n1, n2);
00174 SetDirty(key);
00175 Post(key);
00176 return 1;
00177 }
00178 return 0;
00179 }
00180
00181 template <class Etype>
00182 inline int DataServer::Register_Dynamic_3D_Array(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype ***data, int &n1, int &n2, int &n3)
00183 {
00184 static int elemsize = sizeof(Etype);
00185 if (reg_flag)
00186 RegisterKey(key, DYNAMIC_3D_ARRAY, keyType(data[0][0][0]), elemsize, -1, perm);
00187
00188 char varkey[80];
00189 sprintf(varkey, "%s_dim1", key);
00190 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n1)) return 1;
00191 sprintf(varkey, "%s_dim2", key);
00192 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n2)) return 1;
00193 sprintf(varkey, "%s_dim3", key);
00194 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n3)) return 1;
00195
00196 if (!strcmp(inpkey, key))
00197 {
00198 flag = 0;
00199 Wait(key);
00200 C->SendVar(n1);
00201 C->SendVar(n2);
00202 C->SendVar(n3);
00203 C->SendArray3D(data, n1, n2, n3);
00204 Post(key);
00205 return 1;
00206 }
00207 else if (gotWriteRequest(inpkey, key, perm))
00208 {
00209 flag = 2;
00210 Wait(key);
00211 C->SendVar(n1);
00212 C->SendVar(n2);
00213 C->SendVar(n3);
00214 C->RecvArray3D(data, n1, n2, n3);
00215 SetDirty(key);
00216 Post(key);
00217 return 1;
00218 }
00219 return 0;
00220 }
00221
00222 template <class Etype>
00223 inline int DataServer::Register_Dynamic_4D_Array(RemoteSocket *C, int &flag, bool reg_flag, char *inpkey, char *key, char *perm, Etype ****data, int &n1, int &n2, int &n3, int &n4)
00224 {
00225 static int elemsize = sizeof(Etype);
00226 if (reg_flag)
00227 RegisterKey(key, DYNAMIC_4D_ARRAY, keyType(data[0][0][0][0]), elemsize, -1, perm);
00228
00229 char varkey[80];
00230 sprintf(varkey, "%s_dim1", key);
00231 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n1)) return 1;
00232 sprintf(varkey, "%s_dim2", key);
00233 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n2)) return 1;
00234 sprintf(varkey, "%s_dim3", key);
00235 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n3)) return 1;
00236 sprintf(varkey, "%s_dim4", key);
00237 if (Register_Variable(C, flag, reg_flag, inpkey, varkey, "ro", n4)) return 1;
00238
00239 if (!strcmp(inpkey, key))
00240 {
00241 flag = 0;
00242 Wait(key);
00243 C->SendVar(n1);
00244 C->SendVar(n2);
00245 C->SendVar(n3);
00246 C->SendVar(n4);
00247 C->SendArray4D(data, n1, n2, n3, n4);
00248 Post(key);
00249 return 1;
00250 }
00251 else if (gotWriteRequest(inpkey, key, perm))
00252 {
00253 flag = 2;
00254 Wait(key);
00255 C->SendVar(n1);
00256 C->SendVar(n2);
00257 C->SendVar(n3);
00258 C->SendVar(n4);
00259 C->RecvArray4D(data, n1, n2, n3, n4);
00260 SetDirty(key);
00261 Post(key);
00262 return 1;
00263 }
00264 return 0;
00265 }
00266
00267 template <class Etype>
00268 inline int DataServer::Register_Variable_Internal(RemoteSocket *C, int &flag, char *inpkey, char *key, char *perm, Etype &data)
00269 {
00270 static int elemsize = sizeof(Etype);
00271
00272 if (!strcmp(inpkey, key))
00273 {
00274 flag = 0;
00275 C->SendVar(elemsize);
00276 C->SendVar(data);
00277 return 1;
00278 }
00279 else if (gotWriteRequest(inpkey, key, perm))
00280 {
00281 flag = 2;
00282 Wait();
00283 C->SendVar(elemsize);
00284 C->RecvVar(&data);
00285 Lock();
00286 return 1;
00287 }
00288 return 0;
00289 }
00290
00291 template <class Etype>
00292 inline int DataServer::Register_Structure_Internal(RemoteSocket *C, int &flag, char *inpkey, char *key, char *perm, Etype &data)
00293 {
00294 static int elemsize = sizeof(Etype);
00295
00296 if (!strcmp(inpkey, key))
00297 {
00298 flag = 0;
00299 C->SendStruct(&data, Lock());
00300 return 1;
00301 }
00302 else if (gotWriteRequest(inpkey, key, perm))
00303 {
00304 flag = 2;
00305 C->RecvStruct(&data, Lock());
00306 return 1;
00307 }
00308 return 0;
00309 }
00310
00311 #endif // _DATASERVER_REGISTER_H_
00312
