OSG::BinaryMessage Class Reference

00086                                 :
00087     NetworkMessage(),
00088     _buffer(),
00089     _pos(sizeof(Header))
00090 {
00091     clear();
00092 }

00096                                                        :
00097     NetworkMessage(source),
00098     _buffer(source._buffer),
00099     _pos(source._pos)
00100 {
00101 }

00109 {
00110 }

00167 {
00168     return _buffer.size();
00169 }

00174 {
00175     if(_buffer.size())
00176         return static_cast<MemoryHandle>(&_buffer[0]);
00177     else
00178         return 0;
00179 }

00142 {
00143     _buffer.resize(size);
00144     reset();
00145 }

00150 {
00151     _buffer.resize(sizeof(Header));
00152 }

00157 {
00158     _pos=sizeof(Header);
00159 }

00048 {
00049     UInt32 net = osgHostToNet<UInt32>(value);
00050     _buffer.insert(_buffer.end(),
00051                    reinterpret_cast<UInt8*>(&net),
00052                    reinterpret_cast<UInt8*>(&net) + sizeof(net));
00053 }

00056 {
00057     Int32 net = osgHostToNet<Int32>(value);
00058     _buffer.insert(_buffer.end(),
00059                    reinterpret_cast<UInt8*>(&net),
00060                    reinterpret_cast<UInt8*>(&net) + sizeof(net));
00061 }

00064 {
00065     UInt16 net = osgHostToNet<UInt16>(value);
00066     _buffer.insert(_buffer.end(),
00067                    reinterpret_cast<UInt8*>(&net),
00068                    reinterpret_cast<UInt8*>(&net) + sizeof(net));
00069 }

00072 {
00073     Int16 net = osgHostToNet<Int16>(value);
00074     _buffer.insert(_buffer.end(),
00075                    reinterpret_cast<UInt8*>(&net),
00076                    reinterpret_cast<UInt8*>(&net) + sizeof(net));
00077 }

00080 {
00081     _buffer.push_back(value);
00082 }

00085 {
00086     UInt8 v = static_cast<const UInt8>(value);
00087     _buffer.push_back(v);
00088 }

00091 {
00092     putUInt32(value.size());
00093     if(value.size())
00094     {
00095         const UInt8 *s = reinterpret_cast<const UInt8*>(value.c_str());
00096         const UInt8 *e = s + value.size();
00097         _buffer.insert(_buffer.end(), s, e);
00098     }
00099 }

00102 {
00103     Real32 net = osgHostToNet<Real32>(value);
00104     _buffer.insert(_buffer.end(),
00105                    reinterpret_cast<UInt8*>(&net),
00106                    reinterpret_cast<UInt8*>(&net) + sizeof(net));
00107 }

00113 {
00114     UInt32 net = *reinterpret_cast<UInt32*>(&_buffer[_pos]);
00115     value = osgNetToHost<UInt32>(net);
00116     _pos += sizeof(net);
00117 }

00120 {
00121     Int32 net = *reinterpret_cast<Int32*>(&_buffer[_pos]);
00122     value = osgNetToHost<Int32>(net);
00123     _pos += sizeof(net);
00124 }

00127 {
00128     UInt16 net = *reinterpret_cast<UInt16*>(&_buffer[_pos]);
00129     value = osgNetToHost<UInt16>(net);
00130     _pos += sizeof(net);
00131 }

00134 {
00135     Int16 net = *reinterpret_cast<Int16*>(&_buffer[_pos]);
00136     value = osgNetToHost<Int16>(net);
00137     _pos += sizeof(net);
00138 }

00141 {
00142     value = _buffer[_pos++];
00143 }

00146 {
00147     value = _buffer[_pos++];
00148 }

00151 {
00152     UInt32 size;
00153     getUInt32(size);
00154 
00155     if(size)
00156     {
00157 // error if [] checks index
00158 //        value.assign(reinterpret_cast<char*>(&_buffer[_pos       ]),
00159 //                     reinterpret_cast<char*>(&_buffer[_pos + size]) );
00160 
00161         value.assign(reinterpret_cast<char*>(&(_buffer[_pos])), size);
00162 
00163         _pos += size;
00164     }
00165     else
00166     {
00167         value.erase();
00168     }
00169 }

00172 {
00173     Real32 net = *reinterpret_cast<Real32*>(&_buffer[_pos]);
00174     value = osgNetToHost<Real32>(net);
00175     _pos += sizeof(net);
00176 }

00179 {
00180     UInt32 value;
00181     getUInt32(value);
00182     return value;
00183 }

00186 {
00187     Int32 value;
00188     getInt32(value);
00189     return value;
00190 }

00193 {
00194     UInt16 value;
00195     getUInt16(value);
00196     return value;
00197 }

00200 {
00201     Int16 value;
00202     getInt16(value);
00203     return value;
00204 }

00207 {
00208     UInt8 value;
00209     getUInt8(value);
00210     return value;
00211 }

00214 {
00215     Int8 value;
00216     getInt8(value);
00217     return value;
00218 }

00221 {
00222     std::string value;
00223     getString(value);
00224     return value;
00225 }

00228 {
00229     Real32 value;
00230     getReal32(value);
00231     return value;
00232 }

00118 {
00119     if(this == &source)
00120         return *this;
00121 
00122     // copy parts inherited from parent
00123     *(static_cast<Inherited *>(this)) = source;
00124 
00125     // free mem alloced by members of 'this'
00126 
00127     // alloc new mem for members
00128 
00129     // copy
00130     _buffer=source._buffer;
00131     _pos   =source._pos;
00132     return *this;
00133 }

00098 {
00099     return *((Header*)(getBuffer()));
00100 }