OSG::ExceptionBinaryDataHandler Class Reference

00059                               :
00060 
00061     _readBuffers          (                 ),
00062     _writeBuffers         (                 ),
00063     _zeroCopyBuffers      (                 ),
00064     _zeroCopyThreshold    (zeroCopyThreshold),
00065     _freeMem              (                 ),
00066     _currentReadBuffer    (                 ),
00067     _currentReadBufferPos (0                ),
00068     _currentWriteBuffer   (                 ),
00069     _currentWriteBufferPos(0                ),
00070     _networkOrder         (networkOrder     )
00071 {
00072 }

00078 {
00079     freeMem();
00080 }

00086 {
00087     UInt8 const *data = static_cast<UInt8 const *>(src);
00088 
00089     if(_zeroCopyThreshold && size >= _zeroCopyThreshold)
00090     {
00091         if(_zeroCopyThreshold == 1)
00092         {
00093             write(const_cast<MemoryHandle>(data), size);
00094         }
00095         else
00096         {
00097             UInt8 tag = 1;
00098 
00099             // we have to write a tag, to indicate the membership
00100             // of this zero copy block to the current data block
00101             put(&tag, sizeof(tag));
00102 
00103             _zeroCopyBuffers.push_back(
00104                 MemoryBlock(const_cast<MemoryHandle>(data), size, size));
00105         }
00106     }
00107     else
00108     {
00109         UInt32 copySize;
00110 
00111         while(size != 0)
00112         {
00113             if(_currentWriteBuffer == writeBufEnd())
00114             {
00115                 pushBuffer();
00116             }
00117 
00118             copySize = osgMin((_currentWriteBuffer->getSize() -
00119                                _currentWriteBufferPos),
00120                               size);
00121 
00122             memcpy(_currentWriteBuffer->getMem() + _currentWriteBufferPos,
00123                     data,
00124                     copySize);
00125 
00126              size                  -= copySize;
00127             _currentWriteBufferPos += copySize;
00128              data                  += copySize;
00129 
00130             // skip to next buffer if current buffer is full
00131             if(_currentWriteBufferPos == _currentWriteBuffer->getSize())
00132             {
00133                 _currentWriteBuffer->setDataSize(_currentWriteBufferPos);
00134                 _currentWriteBuffer++;
00135                 _currentWriteBufferPos = 0;
00136             }
00137         }
00138     }
00139 }

00147 {
00148     put(src, size);
00149 
00150     if(_zeroCopyThreshold && size > _zeroCopyThreshold)
00151     {
00152         _freeMem.push_back(src);
00153     }
00154     else
00155     {
00156         delete [] src;
00157     }
00158 }

00057 {
00058     // on Mac OS X a bool is four bytes long on all other
00059     // platfroms it is one byte long. So we write now always
00060     // one byte out.
00061     // put(&value, sizeof(bool));
00062     UInt8 temp = (UInt8) value;
00063     put(&temp, sizeof(UInt8));
00064 }

00068 {
00069     put(&value, sizeof(UInt8));
00070 }

00074 {
00075     UInt16 z = osgHostToNet<UInt16>(value);
00076 
00077     put(&z, sizeof(UInt16));
00078 }

00082 {
00083     UInt32 z = osgHostToNet<UInt32>(value);
00084 
00085     put(&z, sizeof(UInt32));
00086 }

00090 {
00091     UInt64 z = osgHostToNet<UInt64>(value);
00092 
00093     put(&z, sizeof(UInt64));
00094 }

00098 {
00099     put(&value, sizeof(Int8));
00100 }

00104 {
00105     Int16 z = osgHostToNet<Int16>(value);
00106 
00107     put(&z, sizeof(Int16));
00108 }

00112 {
00113     Int32 z = osgHostToNet<Int32>(value);
00114 
00115     put(&z, sizeof(Int32));
00116 }

00120 {
00121     Int64 z = osgHostToNet<Int64>(value);
00122 
00123     put(&z, sizeof(Int64));
00124 
00125 }

00129 {
00130     UInt16 v = osgHostToNet<UInt16>(value.bits());
00131 
00132     put(&v, sizeof(Real16));
00133 }

00137 {
00138     Int32 v = osgHostToNet<Int32>(value.getValue());
00139 
00140     put(&v, sizeof(Int32));
00141 }

00145 {
00146     Real32 v = osgHostToNet<Real32>(value);
00147 
00148     put(&v, sizeof(Real32));
00149 }

00153 {
00154     Real64 v = osgHostToNet<Real64>(value);
00155 
00156     put(&v, sizeof(Real64));
00157 }

00161 {
00162     Real128 v = osgHostToNet<Real128>(value);
00163     
00164     // sizeof(Real128) != 16 on most arch - force it.
00165     put(&v, 16);
00166 }

00170 {
00171     UInt32 len = value.length() + 1;
00172 
00173     putValue(len);
00174 
00175     if(len != 0)
00176     {
00177         put(value.c_str(), len);
00178     }
00179 }

00193 {
00194     for(UInt32 i = 0; i < size; ++i)
00195         putValue(value[i]);
00196 }

00200 {
00201     put(value, size * sizeof(UInt8));
00202 }

00206 {
00207 #if BYTE_ORDER == LITTLE_ENDIAN
00208 
00209     if(_networkOrder == true)
00210     {
00211         for(UInt32 i = 0; i < size; ++i)
00212         {
00213             putValue(value[i]);
00214         }
00215     }
00216     else
00217 #endif
00218     {
00219         put(value, size * sizeof(UInt16));
00220     }
00221 }

00225 {
00226 #if BYTE_ORDER == LITTLE_ENDIAN
00227     if(_networkOrder == true)
00228     {
00229         for(UInt32 i = 0; i < size; ++i)
00230         {
00231             putValue(value[i]);
00232         }
00233     }
00234     else
00235 #endif
00236     {
00237         put(value, size * sizeof(UInt32));
00238     }
00239 }

00243 {
00244 #if BYTE_ORDER == LITTLE_ENDIAN
00245     if(_networkOrder == true)
00246     {
00247         for(UInt32 i = 0; i < size; ++i)
00248         {
00249             putValue(value[i]);
00250         }
00251     }
00252     else
00253 #endif
00254     {
00255         put(value, size * sizeof(UInt64));
00256     }
00257 }

00261 {
00262 #if BYTE_ORDER == LITTLE_ENDIAN
00263     if(_networkOrder == true)
00264     {
00265         for(UInt32 i = 0; i < size; ++i)
00266         {
00267             putValue(value[i]);
00268         }
00269     }
00270     else
00271 #endif
00272     {
00273         put(value, size * sizeof(Int8));
00274     }
00275 }

00279 {
00280 #if BYTE_ORDER == LITTLE_ENDIAN
00281     if(_networkOrder == true)
00282     {
00283         for(UInt32 i = 0; i < size; ++i)
00284         {
00285             putValue(value[i]);
00286         }
00287     }
00288     else
00289 #endif
00290     {
00291         put(value, size * sizeof(Int16));
00292     }
00293 }

00297 {
00298 #if BYTE_ORDER == LITTLE_ENDIAN
00299     if(_networkOrder == true)
00300     {
00301         for(UInt32 i = 0; i < size; ++i)
00302         {
00303             putValue(value[i]);
00304         }
00305     }
00306     else
00307 #endif
00308     {
00309         put(value, size * sizeof(Int32));
00310     }
00311 }

00315 {
00316 #if BYTE_ORDER == LITTLE_ENDIAN
00317     if(_networkOrder == true)
00318     {
00319         for(UInt32 i = 0; i < size; ++i)
00320         {
00321             putValue(value[i]);
00322         }
00323     }
00324     else
00325 #endif
00326     {
00327         put(value, size * sizeof(Int64));
00328     }
00329 }

00333 {
00334 #if BYTE_ORDER == LITTLE_ENDIAN
00335     if(_networkOrder == true)
00336     {
00337         for(UInt32 i = 0; i < size; ++i)
00338         {
00339             putValue(value[i]);
00340         }
00341     }
00342     else
00343 #endif
00344     {
00345         put(value, size * sizeof(Real16));
00346     }
00347 }

00351 {
00352 #if BYTE_ORDER == LITTLE_ENDIAN
00353     if(_networkOrder == true)
00354     {
00355         for(UInt32 i = 0; i < size; ++i)
00356         {
00357             putValue(value[i]);
00358         }
00359     }
00360     else
00361 #endif
00362     {
00363         put(value, size * sizeof(Fixed32));
00364     }
00365 }

00369 {
00370 #if BYTE_ORDER == LITTLE_ENDIAN
00371     if(_networkOrder == true)
00372     {
00373         for(UInt32 i = 0; i < size; ++i)
00374         {
00375             putValue(value[i]);
00376         }
00377     }
00378     else
00379 #e