Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

MGridforceParamsList Class Reference

#include <MGridforceParams.h>

List of all members.

Public Member Functions

 MGridforceParamsList ()
 ~MGridforceParamsList ()
void clear ()
MGridforceParams * find_key (const char *key)
int index_for_key (const char *key)
MGridforceParams * add (const char *key)
MGridforceParams * get_first ()
void pack_data (MOStream *msg)
void unpack_data (MIStream *msg)

Static Public Member Functions

int atoBool (const char *s)

Constructor & Destructor Documentation

MGridforceParamsList::MGridforceParamsList (   )  [inline]
 

Definition at line 50 of file MGridforceParams.h.

00050                          {
00051     clear();
00052   }

MGridforceParamsList::~MGridforceParamsList (   )  [inline]
 

Definition at line 54 of file MGridforceParams.h.

00055   {
00056     MGFElem* cur;
00057     while (head != NULL) {
00058       cur = head;
00059       head = cur->nxt;
00060       delete cur;
00061     }
00062     clear();
00063   }

Member Function Documentation

MGridforceParams * MGridforceParamsList::add (  const char *  key  ) 
 

Definition at line 53 of file MGridforceParams.C.

References find_key(), MGridforceParams::gridforceCol, MGridforceParams::gridforceFile, MGridforceParams::gridforceKey, MGridforceParams::gridforceQcol, MGridforceParams::gridforceVfile, and MGridforceParams::next.

Referenced by unpack_data().

00054 {
00055     // If the key is already in the list, we can't add it
00056     if (find_key(key)!=NULL) {
00057       return NULL;
00058     }
00059     
00060     MGFElem* new_elem = new MGFElem();
00061     int len = strlen(key);
00062     MGridforceParams* elem = &(new_elem->elem);
00063     elem->gridforceKey = new char[len+1];
00064     strncpy(elem->gridforceKey,key,len+1);
00065     elem->gridforceVfile = NULL;
00066     elem->gridforceFile = NULL;
00067     elem->gridforceCol = NULL;
00068     elem->gridforceQcol = NULL;
00069     elem->next = NULL;
00070     new_elem->nxt = NULL;
00071     if (head == NULL) {
00072       head = new_elem;
00073     }
00074     if (tail != NULL) {
00075       tail->nxt = new_elem;
00076       tail->elem.next = elem;
00077     }
00078     tail = new_elem;
00079     n_elements++;
00080     
00081     return elem;
00082 }

int MGridforceParamsList::atoBool (  const char *  s  )  [inline, static]
 

Definition at line 87 of file MGridforceParams.h.

00088   {
00089     if (!strcasecmp(s, "on")) return 1;
00090     if (!strcasecmp(s, "off")) return 0;
00091     if (!strcasecmp(s, "true")) return 1;
00092     if (!strcasecmp(s, "false")) return 0;
00093     if (!strcasecmp(s, "yes")) return 1;
00094     if (!strcasecmp(s, "no")) return 0;
00095     if (!strcasecmp(s, "1")) return 1;
00096     if (!strcasecmp(s, "0")) return 0;
00097     return -1;
00098   }

void MGridforceParamsList::clear (   )  [inline]
 

Definition at line 68 of file MGridforceParams.h.

Referenced by SimParameters::receive_SimParameters().

00068                {
00069     head = tail = NULL;
00070     n_elements = 0;
00071   }

MGridforceParams * MGridforceParamsList::find_key (  const char *  key  ) 
 

Definition at line 13 of file MGridforceParams.C.

Referenced by add(), and Node::reloadGridforceGrid().

00014 {
00015     MGFElem* cur = head;
00016     MGFElem* found = NULL;
00017     MGridforceParams* result = NULL;
00018     
00019     while (found == NULL && cur != NULL) {
00020        if (!strcasecmp((cur->elem).gridforceKey,key)) {
00021         found = cur;
00022       } else {
00023         cur = cur->nxt;
00024       }
00025     }
00026     if (found != NULL) {
00027       result = &(found->elem);
00028     }
00029     return result;
00030 }

MGridforceParams* MGridforceParamsList::get_first (   )  [inline]
 

Definition at line 77 of file MGridforceParams.h.

Referenced by Molecule::build_gridforce_params(), and pack_data().

00077                                 {
00078     if (head == NULL) {
00079       return NULL;
00080     } else return &(head->elem);
00081   }

int MGridforceParamsList::index_for_key (  const char *  key  ) 
 

Definition at line 32 of file MGridforceParams.C.

Referenced by Node::reloadGridforceGrid().

00033 {
00034     MGFElem* cur = head;
00035     MGFElem* found = NULL;
00036     int result = -1;
00037     
00038     int idx = 0;
00039     while (found == NULL && cur != NULL) {
00040        if (!strcasecmp((cur->elem).gridforceKey,key)) {
00041         found = cur;
00042       } else {
00043         cur = cur->nxt;
00044         idx++;
00045       }
00046     }
00047     if (found != NULL) {
00048         result = idx;
00049     }
00050     return result;
00051 }

void MGridforceParamsList::pack_data (  MOStream *  msg  ) 
 

Definition at line 84 of file MGridforceParams.C.

References get_first(), MGridforceParams::gridforceCol, MGridforceParams::gridforceCont, MGridforceParams::gridforceFile, MGridforceParams::gridforceKey, MGridforceParams::gridforceLite, MGridforceParams::gridforceQcol, MGridforceParams::gridforceScale, MGridforceParams::gridforceVfile, MGridforceParams::gridforceVOffset, MGridforceParams::gridforceVolts, NAMD_die(), MGridforceParams::next, and MOStream::put().

Referenced by SimParameters::send_SimParameters().

00085 {
00086     int i = n_elements;
00087     msg->put(n_elements);
00088     MGridforceParams *elem = get_first();
00089     while (elem != NULL) {
00090       int len;
00091       len = strlen(elem->gridforceKey) + 1;
00092       msg->put(len);
00093       msg->put(len,elem->gridforceKey);
00094 
00095       len = strlen(elem->gridforceVfile) + 1;
00096       msg->put(len);
00097       msg->put(len,elem->gridforceVfile);
00098 
00099       Vector v = elem->gridforceScale;
00100       msg->put(&v);
00101       
00102       len = strlen(elem->gridforceFile) + 1;
00103       msg->put(len);
00104       msg->put(len,elem->gridforceFile);
00105       
00106       len = strlen(elem->gridforceCol) + 1;
00107       msg->put(len);
00108       msg->put(len,elem->gridforceCol);
00109       
00110       if (elem->gridforceQcol == NULL) 
00111         msg->put(1); // Qcol_is_null = true
00112       else {
00113         msg->put(0); // Qcol_is_null = false
00114         len = strlen(elem->gridforceQcol) + 1;
00115         msg->put(len);
00116         msg->put(len,elem->gridforceQcol);
00117       }
00118       
00119       v = elem->gridforceVOffset;
00120       msg->put(&v);
00121       
00122       short boolvals[5];
00123       boolvals[0] = (elem->gridforceCont[0] ? 1 : 0);
00124       boolvals[1] = (elem->gridforceCont[1] ? 1 : 0);
00125       boolvals[2] = (elem->gridforceCont[2] ? 1 : 0);
00126       boolvals[3] = (elem->gridforceVolts ? 1 : 0);
00127       boolvals[4] = (elem->gridforceLite ? 1 : 0);
00128       msg->put(5,boolvals);
00129       
00130       i--;
00131       elem = elem->next;
00132     }
00133     if (i != 0) {
00134       NAMD_die("MGridforceParams message packing error\n");
00135     }
00136     return;
00137 }

void MGridforceParamsList::unpack_data (  MIStream *  msg  ) 
 

Definition at line 139 of file MGridforceParams.C.

References add(), MIStream::get(), MGridforceParams::gridforceCol, MGridforceParams::gridforceCont, MGridforceParams::gridforceFile, MGridforceParams::gridforceLite, MGridforceParams::gridforceQcol, MGridforceParams::gridforceScale, MGridforceParams::gridforceVfile, MGridforceParams::gridforceVOffset, and MGridforceParams::gridforceVolts.

Referenced by SimParameters::receive_SimParameters().

00140 {
00141     int elements;
00142     msg->get(elements);
00143     
00144     for(int i=0; i < elements; i++) {
00145       // Get key
00146       int len;
00147       msg->get(len);
00148       char *key = new char[len];
00149       msg->get(len,key);
00150       MGridforceParams *elem = add(key);
00151       
00152       msg->get(len);
00153       char *str = new char[len];
00154       msg->get(len,str);
00155       elem->gridforceVfile = str;
00156 
00157       Vector v;
00158       msg->get(&v);
00159       elem->gridforceScale = v;
00160       
00161       msg->get(len);
00162       str = new char[len];
00163       msg->get(len,str);
00164       elem->gridforceFile = str;
00165       
00166       msg->get(len);
00167       str = new char[len];
00168       msg->get(len,str);
00169       elem->gridforceCol = str;
00170       
00171       int qcol_is_null;
00172       msg->get(qcol_is_null);
00173       if (qcol_is_null)
00174         elem->gridforceQcol = NULL;
00175       else {
00176         msg->get(len);
00177         str = new char[len];
00178         msg->get(len,str);
00179         elem->gridforceQcol = str;
00180       }
00181       
00182       msg->get(&v);
00183       elem->gridforceVOffset = v;
00184       
00185       short boolvals[5];
00186       msg->get(5,boolvals);
00187       elem->gridforceCont[0] = ( boolvals[0] != 0 );
00188       elem->gridforceCont[1] = ( boolvals[1] != 0 );
00189       elem->gridforceCont[2] = ( boolvals[2] != 0 );
00190       elem->gridforceVolts = ( boolvals[3] != 0 );
00191       elem->gridforceLite = ( boolvals[4] != 0 );
00192       
00193       delete [] key;
00194     }
00195 }

The documentation for this class was generated from the following files:
Generated on Fri May 25 04:07:22 2012 for NAMD by  doxygen 1.3.9.1