Changeset 254 for trunk/src/mesh

Timestamp:

Mar 2, 2006 9:07:05 AM (18 years ago)

Author:

cxsong

Message:

modified serialization/deserializaiton functions, added xmlString, print, capacity, etc.

Location:

trunk/src/mesh

Files:

• grid1d.cc (modified) (6 diffs)
• grid1d.h (modified) (2 diffs)

trunk/src/mesh/grid1d.cc

@@ -13 +13 @@
 RpGrid1d::RpGrid1d(int size)
 {
-        m_data.resize(size);
+        m_data.reserve(size);
 }
 
@@ -41 +41 @@
 }
 
+//
+// Add all points to grid1d object at once
+//
+RP_ERROR 
+RpGrid1d::addAllPoints(double* val, int nitems)
+{
+        if (val == NULL)
+                return RP_ERR_NULL_PTR;
+
+        if (nitems != numPoints())
+                m_data.resize(nitems);
+
+        for (int i=0; i < nitems; i++)
+                m_data[i] = val[i];
+
+        return RP_SUCCESS;
+}
+
+//
+// add one point to grid1d
+//
 void RpGrid1d::addPoint(double val)
 {
@@ -55 +76 @@
 //
 char* 
-RpGrid1d::serialize(RP_ENCODE_ALG encodeFlag, RP_COMPRESSION compressFlag)
+RpGrid1d::serialize(int& nb, RP_ENCODE_ALG encodeFlag, 
+                                RP_COMPRESSION compressFlag)
 {
         int npts = m_data.size(); 
+        int nbytes = npts*sizeof(double) + sizeof(int) + 2;
+        char* buf;
 
         // total length = tagEncode + tagCompress + num + array data 
-        char * buf = (char*) malloc(npts*sizeof(double) + sizeof(int) + 2);
-        if (buf == NULL) {
+        if ( (buf = (char*) malloc(nbytes)) == NULL) {
                 RpAppendErr("RpGrid1d::serialize: malloc failed");
                 RpPrintErr();
@@ -67 +90 @@
         }
 
+        serialize(buf, nbytes, encodeFlag, compressFlag);
+        nb = nbytes;
+
+        return buf;
+}
+
+RP_ERROR
+RpGrid1d::serialize(char* buf, int nbytes, RP_ENCODE_ALG encodeFlag, 
+                RP_COMPRESSION compressFlag)
+{
+        int npts = m_data.size();
+
+        if (buf == NULL || (unsigned)nbytes < (npts*sizeof(double)+sizeof(int)+2)) {
+                RpAppendErr("RpGrid1d::serialize: invalid buffer");
+                RpPrintErr();
+                return RP_ERR_INVALID_ARRAY;
+        }
+        
         char* ptr = buf;
-        
         ptr[0] = 'N'; // init to no-encoding
         switch(encodeFlag) {
@@ -88 +128 @@
                         break;
         }
+        ptr += 2; // advance pointer
 
         // TODO encode, compression
-        //
+        // compress()
 
         // write to stream buffer
-        ptr += 2;
         memcpy((void*)ptr, (void*)&npts, sizeof(int));
         ptr += sizeof(int);
         memcpy((void*)ptr, (void*)&(m_data[0]), npts*sizeof(double));
 
-        return buf;
-}
-
-int 
+        return RP_SUCCESS;
+}
+
+RP_ERROR 
 RpGrid1d::deserialize(const char* buf)
 {
@@ -134 +174 @@
 }
 
-
-//TODO: overload operators [], =
+void 
+RpGrid1d::xmlString(std::string& textString)
+{
+        int i;
+        int npts = m_data.size();
+        char cstr[256];
+        std::string str;
+
+        // clear input string
+        textString.erase();
+
+        textString.append("<value>");
+
+        for (i=0; i < npts; i++) {
+                sprintf(cstr, "\t%.15f\n", m_data[i]);
+                textString.append(cstr);
+        }
+        textString.append("</value>\n");
+}
+
+void 
+RpGrid1d::print()
+{
+        string str;
+        xmlString(str);
+        printf("%s", str.c_str());
+}
+
 
 // TODO

trunk/src/mesh/grid1d.h

@@ -17 +17 @@
         RpGrid1d(const char* buf); // instantiate with byte stream
 
+        // add all points to grid
+        RP_ERROR addAllPoints(double* val, int nitems);
+
+        // add one point to grid
         void addPoint(double val);
 
@@ -22 +26 @@
         int numPoints() { return m_data.size(); }
 
+        // max num points that can be stored
+        int capacity() { return m_data.capacity(); }
+
         // change the size of the grid after grid is constructed
         void resize(int npoints) { m_data.resize(npoints); }
 
         // serialize data 
-        char * serialize(RP_ENCODE_ALG eflag=RP_NO_ENCODING, 
+        // If no input parameters are provided, byte stream will be binary
+        // without compression.
+        //
+        char * serialize(int& nbytes, RP_ENCODE_ALG eflag=RP_NO_ENCODING, 
                          RP_COMPRESSION cflag=RP_NO_COMPRESSION);
-        int deserialize(const char* buf);
+
+        RP_ERROR serialize(char * buf, int nbytes,
+                        RP_ENCODE_ALG eflag=RP_NO_ENCODING, 
+                        RP_COMPRESSION cflag=RP_NO_COMPRESSION);
+
+        RP_ERROR deserialize(const char* buf);
+
+        void xmlString(std::string& str);
+        void print();
 
         // destructor