Changeset 330 for trunk/src/mesh


Ignore:
Timestamp:
Mar 12, 2006 8:25:02 PM (18 years ago)
Author:
cxsong
Message:

updated handling of RpField? linkage to mesh object
updated clear() to clean up buffer

Location:
trunk/src/mesh
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/mesh/serializer.cc

    r321 r330  
    1515        // add object entry to reference count table
    1616        m_refCount[key] = 0;
     17
     18        /*
     19        // handle mesh object embedded in field
     20        if (obj->objectType() == RpObjectTypes[FIELD] ) {
     21                addObject(((RpField*)obj)->getMeshId(),
     22                          ((RpField*)obj)->getMeshObj());
     23                printf("addObject:
     24        }
     25        */
     26
    1727#ifdef DEBUG
    1828        printf("RpSerializer::addObject: obj name=%s, ptr=%x\n", key, (unsigned int)obj);
     
    2131}
    2232
    23 //
    24 // Input:
    25 //      a byte stream of a serialized object
    26 //              RV-A-<object-type><numBytes>.....
    27 //
    28 /*
    29 void
    30 RpSerializer::addObject(const char* buf)
    31 {
    32 }
    33 */
     33void
     34RpSerializer::addObject(const char* key, RpSerializable* ptr)
     35{
     36
     37        m_objMap[key] = ptr;
     38        m_refCount[key] = 0;
     39}
    3440
    3541//
     
    4248{
    4349        typeObjMap::iterator iter = m_objMap.find(name);
     50        if (iter == m_objMap.end())
     51                // does not exist
     52                return;
     53
     54        RpSerializable* obj = (*iter).second;
     55
     56        // handle RpField - update mesh ref count
     57        if (obj->objectType() == RpObjectTypes[FIELD]) {
     58                deleteObject( ((RpField*)obj)->getMeshId() );
     59        }
     60
     61        // decrement object's reference count
     62        // if reference count is zero, free memory and remove entry in obj map
     63        if ( (--(m_refCount[name])) == 0) {
     64                delete obj; // free obj memory
     65                m_objMap.erase(name); // erase entry in object map
     66                m_refCount.erase(name); // erase entry in object map
     67        }
     68
     69        return;
     70}
     71
     72void
     73RpSerializer::deleteObject(RpSerializable* obj)
     74{
     75        const char* name = obj->objectName();
     76        typeObjMap::iterator iter = m_objMap.find(name);
     77
    4478        if (iter == m_objMap.end())
    4579                // does not exist
     
    6094
    6195void
    62 RpSerializer::deleteObject(RpSerializable* obj)
    63 {
    64         const char* name = obj->objectName();
    65         typeObjMap::iterator iter = m_objMap.find(name);
    66 
    67         if (iter == m_objMap.end())
    68                 // does not exist
    69                 return;
    70 
    71         RpSerializable* obj_ptr = (*iter).second;
    72 
    73         // decrement object's reference count
    74         // if reference count is zero, free memory and remove entry in obj map
    75         if ( (--(m_refCount[name])) == 0) {
    76                 delete obj_ptr; // free obj memory
    77                 m_objMap.erase(name); // erase entry in object map
    78                 m_refCount.erase(name); // erase entry in object map
    79         }
    80 
    81         return;
    82 }
    83 
    84 void
    8596RpSerializer::deleteAllObjects()
    8697{
     
    93104        m_objMap.clear();
    94105        m_refCount.clear();
    95         m_numObjects = 0;
    96106}
    97107
     
    100110{
    101111        deleteAllObjects();
     112
     113        delete [] m_buf;
     114        m_buf = 0;
    102115}
    103116
     
    118131                // object found, increment ref count
    119132                ++(m_refCount[objectName]);
     133
     134                // special handling of field object with link to mesh
     135                RpSerializable* ptmp = (*iter).second;
     136                if ( (ptmp->objectType() == RpObjectTypes[FIELD]) ) {
     137               
     138                        RpField* ftmp = (RpField*)ptmp;
     139
     140                        // find mesh obj ptr in serializer
     141                        typeObjMap::iterator it = m_objMap.find(ftmp->getMeshId());
     142                        if (it != m_objMap.end()) { //found mesh obj
     143                                ftmp->setMeshObj( ((*it).second) );
     144                                ++(m_refCount[ftmp->getMeshId()]);
     145                        }
     146                        else {
     147                                RpAppendErr("RpSerializer::getObject: field without mesh data\n");
     148                                RpPrintErr();
     149                        }
     150                }
    120151
    121152                // return pointer to object
     
    155186       
    156187        // allocate memory
    157         char* buf = new char[nbytes];
    158         if (buf == NULL) {
    159                 printf("RpSerializer::serialize(): failed to allocate mem\n");
    160                 return buf;
    161         }
    162 
    163         writeHeader(buf, nbytes, "NO", "NO");
     188        if (m_buf) {
     189                delete [] m_buf;
     190        }
     191
     192        m_buf = new char[nbytes];
     193        if (m_buf == NULL) {
     194                RpAppendErr("RpSerializer::serialize(): failed to allocate mem\n");
     195                RpPrintErr();
     196                return m_buf;
     197        }
     198
     199        writeHeader(m_buf, nbytes, "NO", "NO");
    164200
    165201        // call each object to serialize itself
    166         char* ptr = buf + headerSize();
     202        char* ptr = m_buf + headerSize();
    167203
    168204        typeObjMap::iterator iter;
     
    176212
    177213        // return pointer to buffer
    178         return buf;
     214        return m_buf;
    179215}
    180216
     
    330366
    331367}
     368
  • trunk/src/mesh/serializer.h

    r321 r330  
    55#include <map>
    66#include <string>
     7#include "serializable.h"
    78#include "field.h"
    8 #include "serializable.h"
     9#include "util.h"
    910
    1011//
     
    1415public:
    1516
    16         RpSerializer() { };
     17        RpSerializer() { m_buf = 0; };
    1718
    1819        // remove all objects, reset ref counts to zero.
     20        // delete buffer memory so the caller does not need to
    1921        void clear();
    2022
    2123        void addObject(RpSerializable* obj);
    22         //void addObject(const char* buf);
     24        void addObject(const char* key, RpSerializable* obj);
    2325
    2426        void deleteObject(RpSerializable* obj);
     
    7880        typeRefCount m_refCount;
    7981
    80         unsigned int m_numObjects; //? can get from map.size()
     82        char* m_buf; // tmp buffer for serialization
    8183};
    8284
Note: See TracChangeset for help on using the changeset viewer.