simgear/hla/RTIData.hxx

   1 // Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Library General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Library General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16 //
  17
  18 #ifndef RTIData_hxx
  19 #define RTIData_hxx
  20
  21 #include <cstring>
  22 #include <list>
  23 #include <simgear/misc/stdint.hxx>
  24
  25 namespace simgear {
  26
  27 /// Sigh, this is std::vector<char>, except that
  28 /// you could feed that with external pointers without copying ...
  29 /// Note on alignment: the c++ standard garantees (5.3.4.10) that
  30 /// new (unsigned) char returns sufficiently aligned memory
  31 /// for all relevant cases
  32 class RTIData {
  33 public:
  34     RTIData() :
  35         _data(0),
  36         _size(0),
  37         _capacity(0)
  38     { }
  39     RTIData(unsigned size) :
  40         _data(0),
  41         _size(0),
  42         _capacity(0)
  43     { resize(size); }
  44     RTIData(char* data, unsigned size) :
  45         _data(data),
  46         _size(size),
  47         _capacity(0)
  48     { }
  49     RTIData(const char* data, unsigned size) :
  50         _data(0),
  51         _size(0),
  52         _capacity(0)
  53     { setData(data, size); }
  54     RTIData(const char* data) :
  55         _data(0),
  56         _size(0),
  57         _capacity(0)
  58     { setData(data); }
  59     RTIData(const RTIData& data) :
  60         _data(0),
  61         _size(0),
  62         _capacity(0)
  63     {
  64         unsigned size = data.size();
  65         if (size) {
  66             resize(size);
  67             memcpy(_data, data.data(), size);
  68         }
  69     }
  70     ~RTIData()
  71     {
  72         if (_capacity)
  73             delete [] _data;
  74         _data = 0;
  75     }
  76
  77     const char* data() const
  78     { return _data; }
  79     char* data()
  80     { return _data; }
  81
  82     unsigned size() const
  83     { return _size; }
  84
  85     bool empty() const
  86     { return _size == 0; }
  87
  88     void clear()
  89     {
  90         if (_capacity == 0) {
  91             _data = 0;
  92             _size = 0;
  93         } else
  94             resize(0);
  95     }
  96
  97     void resize(unsigned size)
  98     {
  99         if (size == _size)
 100             return;
 101         if (_capacity < size) {
 102             unsigned capacity = 2*_capacity;
 103             if (size < capacity)
 104                 ensureCapacity(capacity);
 105             else
 106                 ensureCapacity(size);
 107         }
 108         _size = size;
 109     }
 110
 111     void reserve(unsigned capacity)
 112     {
 113         if (capacity <= _capacity)
 114             return;
 115         ensureCapacity(capacity);
 116     }
 117
 118     void setData(char* data, unsigned size)
 119     {
 120         if (_capacity)
 121             delete [] _data;
 122         _data = data;
 123         _size = size;
 124         _capacity = 0;
 125     }
 126     void setData(const char* data, unsigned size)
 127     {
 128         resize(size);
 129         if (!size)
 130             return;
 131         memcpy(_data, data, size);
 132     }
 133     void setData(const char* data)
 134     {
 135         if (!data) {
 136             setData("", 1);
 137         } else {
 138             size_t size = strlen(data) + 1;
 139             setData(data, size);
 140         }
 141     }
 142
 143     RTIData& operator=(const RTIData& data)
 144     {
 145         unsigned size = data.size();
 146         if (size) {
 147             resize(size);
 148             memcpy(_data, data.data(), size);
 149         }
 150         return *this;
 151     }
 152
 153     void getData8(char data[1], unsigned offset = 0) const
 154     {
 155         data[0] = _data[offset];
 156     }
 157
 158     void setData8(const char data[1], unsigned offset = 0)
 159     {
 160         _data[offset] = data[0];
 161     }
 162
 163     void getData16LE(char data[2], unsigned offset = 0) const
 164     {
 165         if (hostIsLittleEndian()) {
 166             data[0] = _data[offset];
 167             data[1] = _data[offset+1];
 168         } else {
 169             data[1] = _data[offset];
 170             data[0] = _data[offset+1];
 171         }
 172     }
 173     void setData16LE(const char data[2], unsigned offset = 0)
 174     {
 175         if (hostIsLittleEndian()) {
 176             _data[offset] = data[0];
 177             _data[offset+1] = data[1];
 178         } else {
 179             _data[offset] = data[1];
 180             _data[offset+1] = data[0];
 181         }
 182     }
 183
 184     void getData16BE(char data[2], unsigned offset = 0) const
 185     {
 186         if (hostIsLittleEndian()) {
 187             data[1] = _data[offset];
 188             data[0] = _data[offset+1];
 189         } else {
 190             data[0] = _data[offset];
 191             data[1] = _data[offset+1];
 192         }
 193     }
 194     void setData16BE(const char data[2], unsigned offset = 0)
 195     {
 196         if (hostIsLittleEndian()) {
 197             _data[offset] = data[1];
 198             _data[offset+1] = data[0];
 199         } else {
 200             _data[offset] = data[0];
 201             _data[offset+1] = data[1];
 202         }
 203     }
 204
 205
 206     void getData32LE(char data[4], unsigned offset = 0) const
 207     {
 208         if (hostIsLittleEndian()) {
 209             data[0] = _data[offset];
 210             data[1] = _data[offset+1];
 211             data[2] = _data[offset+2];
 212             data[3] = _data[offset+3];
 213         } else {
 214             data[3] = _data[offset];
 215             data[2] = _data[offset+1];
 216             data[1] = _data[offset+2];
 217             data[0] = _data[offset+3];
 218         }
 219     }
 220     void setData32LE(const char data[4], unsigned offset = 0)
 221     {
 222         if (hostIsLittleEndian()) {
 223             _data[offset] = data[0];
 224             _data[offset+1] = data[1];
 225             _data[offset+2] = data[2];
 226             _data[offset+3] = data[3];
 227         } else {
 228             _data[offset] = data[3];
 229             _data[offset+1] = data[2];
 230             _data[offset+2] = data[1];
 231             _data[offset+3] = data[0];
 232         }
 233     }
 234
 235     void getData32BE(char data[4], unsigned offset = 0) const
 236     {
 237         if (hostIsLittleEndian()) {
 238             data[3] = _data[offset];
 239             data[2] = _data[offset+1];
 240             data[1] = _data[offset+2];
 241             data[0] = _data[offset+3];
 242         } else {
 243             data[0] = _data[offset];
 244             data[1] = _data[offset+1];
 245             data[2] = _data[offset+2];
 246             data[3] = _data[offset+3];
 247         }
 248     }
 249     void setData32BE(const char data[4], unsigned offset = 0)
 250     {
 251         if (hostIsLittleEndian()) {
 252             _data[offset] = data[3];
 253             _data[offset+1] = data[2];
 254             _data[offset+2] = data[1];
 255             _data[offset+3] = data[0];
 256         } else {
 257             _data[offset] = data[0];
 258             _data[offset+1] = data[1];
 259             _data[offset+2] = data[2];
 260             _data[offset+3] = data[3];
 261         }
 262     }
 263
 264
 265     void getData64LE(char data[8], unsigned offset = 0) const
 266     {
 267         if (hostIsLittleEndian()) {
 268             data[0] = _data[offset];
 269             data[1] = _data[offset+1];
 270             data[2] = _data[offset+2];
 271             data[3] = _data[offset+3];
 272             data[4] = _data[offset+4];
 273             data[5] = _data[offset+5];
 274             data[6] = _data[offset+6];
 275             data[7] = _data[offset+7];
 276         } else {
 277             data[7] = _data[offset];
 278             data[6] = _data[offset+1];
 279             data[5] = _data[offset+2];
 280             data[4] = _data[offset+3];
 281             data[3] = _data[offset+4];
 282             data[2] = _data[offset+5];
 283             data[1] = _data[offset+6];
 284             data[0] = _data[offset+7];
 285         }
 286     }
 287     void setData64LE(const char data[8], unsigned offset = 0)
 288     {
 289         if (hostIsLittleEndian()) {
 290             _data[offset] = data[0];
 291             _data[offset+1] = data[1];
 292             _data[offset+2] = data[2];
 293             _data[offset+3] = data[3];
 294             _data[offset+4] = data[4];
 295             _data[offset+5] = data[5];
 296             _data[offset+6] = data[6];
 297             _data[offset+7] = data[7];
 298         } else {
 299             _data[offset] = data[7];
 300             _data[offset+1] = data[6];
 301             _data[offset+2] = data[5];
 302             _data[offset+3] = data[4];
 303             _data[offset+4] = data[3];
 304             _data[offset+5] = data[2];
 305             _data[offset+6] = data[1];
 306             _data[offset+7] = data[0];
 307         }
 308     }
 309
 310     void getData64BE(char data[8], unsigned offset = 0) const
 311     {
 312         if (hostIsLittleEndian()) {
 313             data[7] = _data[offset];
 314             data[6] = _data[offset+1];
 315             data[5] = _data[offset+2];
 316             data[4] = _data[offset+3];
 317             data[3] = _data[offset+4];
 318             data[2] = _data[offset+5];
 319             data[1] = _data[offset+6];
 320             data[0] = _data[offset+7];
 321         } else {
 322             data[0] = _data[offset];
 323             data[1] = _data[offset+1];
 324             data[2] = _data[offset+2];
 325             data[3] = _data[offset+3];
 326             data[4] = _data[offset+4];
 327             data[5] = _data[offset+5];
 328             data[6] = _data[offset+6];
 329             data[7] = _data[offset+7];
 330         }
 331     }
 332     void setData64BE(const char data[8], unsigned offset = 0)
 333     {
 334         if (hostIsLittleEndian()) {
 335             _data[offset] = data[7];
 336             _data[offset+1] = data[6];
 337             _data[offset+2] = data[5];
 338             _data[offset+3] = data[4];
 339             _data[offset+4] = data[3];
 340             _data[offset+5] = data[2];
 341             _data[offset+6] = data[1];
 342             _data[offset+7] = data[0];
 343         } else {
 344             _data[offset] = data[0];
 345             _data[offset+1] = data[1];
 346             _data[offset+2] = data[2];
 347             _data[offset+3] = data[3];
 348             _data[offset+4] = data[4];
 349             _data[offset+5] = data[5];
 350             _data[offset+6] = data[6];
 351             _data[offset+7] = data[7];
 352         }
 353     }
 354
 355
 356 #define TYPED_GETSET_IMPLEMENTATION(type, base, suffix)         \
 357     type get##base##suffix(unsigned offset = 0) const           \
 358     {                                                           \
 359         union {                                                 \
 360             type t;                                             \
 361             char u8[sizeof(type)];                              \
 362         } u;                                                    \
 363         getData##suffix(u.u8, offset);                          \
 364         return u.t;                                             \
 365     }                                                           \
 366     void set##base##suffix(type value, unsigned offset = 0)     \
 367     {                                                           \
 368         union {                                                 \
 369             type t;                                             \
 370             char u8[sizeof(type)];                              \
 371         } u;                                                    \
 372         u.t = value;                                            \
 373         setData##suffix(u.u8, offset);                          \
 374     }
 375
 376     TYPED_GETSET_IMPLEMENTATION(uint8_t, UInt, 8)
 377     TYPED_GETSET_IMPLEMENTATION(int8_t, Int, 8)
 378     TYPED_GETSET_IMPLEMENTATION(uint16_t, UInt, 16LE)
 379     TYPED_GETSET_IMPLEMENTATION(uint16_t, UInt, 16BE)
 380     TYPED_GETSET_IMPLEMENTATION(int16_t, Int, 16LE)
 381     TYPED_GETSET_IMPLEMENTATION(int16_t, Int, 16BE)
 382     TYPED_GETSET_IMPLEMENTATION(uint32_t, UInt, 32LE)
 383     TYPED_GETSET_IMPLEMENTATION(uint32_t, UInt, 32BE)
 384     TYPED_GETSET_IMPLEMENTATION(int32_t, Int, 32LE)
 385     TYPED_GETSET_IMPLEMENTATION(int32_t, Int, 32BE)
 386     TYPED_GETSET_IMPLEMENTATION(uint64_t, UInt, 64LE)
 387     TYPED_GETSET_IMPLEMENTATION(uint64_t, UInt, 64BE)
 388     TYPED_GETSET_IMPLEMENTATION(int64_t, Int, 64LE)
 389     TYPED_GETSET_IMPLEMENTATION(int64_t, Int, 64BE)
 390
 391     TYPED_GETSET_IMPLEMENTATION(float, Float, 32LE)
 392     TYPED_GETSET_IMPLEMENTATION(float, Float, 32BE)
 393     TYPED_GETSET_IMPLEMENTATION(double, Float, 64LE)
 394     TYPED_GETSET_IMPLEMENTATION(double, Float, 64BE)
 395
 396 #undef TYPED_GETSET_IMPLEMENTATION
 397
 398 private:
 399     static inline bool hostIsLittleEndian()
 400     {
 401         union {
 402             uint16_t u16;
 403             uint8_t u8[2];
 404         } u;
 405         u.u16 = 1;
 406         return u.u8[0] == 1;
 407     }
 408
 409     void ensureCapacity(unsigned capacity)
 410     {
 411         if (capacity < 32)
 412             capacity = 32;
 413         char* data = new char[capacity];
 414         if (_size)
 415             memcpy(data, _data, _size);
 416         if (_capacity)
 417             delete [] _data;
 418         _data = data;
 419         _capacity = capacity;
 420     }
 421
 422     char* _data;
 423     unsigned _size;
 424     unsigned _capacity;
 425 };
 426
 427 // A single attribute/parameter update blob
 428 typedef std::pair<unsigned, RTIData> RTIIndexDataPair;
 429
 430 // A complete set of updates we received in one reflect/receive call
 431 typedef std::list<RTIIndexDataPair> RTIIndexDataPairList;
 432
 433 /// Gets an own header at some time
 434
 435 class RTIBasicDataStream {
 436 public:
 437     RTIBasicDataStream() : _offset(0) {}
 438
 439     /// Get aligned offset that aligns to a multiple of size
 440     static inline unsigned getAlignedOffset(unsigned offset, unsigned size)
 441     {
 442         return ((offset + size - 1)/size) * size;
 443     }
 444
 445 protected:
 446     unsigned _offset;
 447 };
 448
 449 class HLADecodeStream : public RTIBasicDataStream {
 450 public:
 451     HLADecodeStream(const RTIData& value) :
 452         _value(value)
 453     { }
 454
 455     bool alignOffsetForSize(unsigned size)
 456     {
 457         _offset = getAlignedOffset(_offset, size);
 458         return _offset <= _value.size();
 459     }
 460
 461     bool skip(unsigned size)
 462     {
 463         _offset += size;
 464         return _offset <= _value.size();
 465     }
 466
 467     bool eof() const
 468     { return _value.size() <= _offset; }
 469
 470     const RTIData& getData() const
 471     { return _value; }
 472
 473 #define TYPED_READ_IMPLEMENTATION(type, base, suffix)           \
 474     bool decode##base##suffix(type& value)                      \
 475     {                                                           \
 476         if (_value.size() < _offset + sizeof(type))             \
 477             return false;                                       \
 478         value = _value.get##base##suffix(_offset);              \
 479         _offset += sizeof(type);                                \
 480         return true;                                            \
 481     }
 482
 483     TYPED_READ_IMPLEMENTATION(uint8_t, UInt, 8)
 484     TYPED_READ_IMPLEMENTATION(int8_t, Int, 8)
 485     TYPED_READ_IMPLEMENTATION(uint16_t, UInt, 16LE)
 486     TYPED_READ_IMPLEMENTATION(uint16_t, UInt, 16BE)
 487     TYPED_READ_IMPLEMENTATION(int16_t, Int, 16LE)
 488     TYPED_READ_IMPLEMENTATION(int16_t, Int, 16BE)
 489     TYPED_READ_IMPLEMENTATION(uint32_t, UInt, 32LE)
 490     TYPED_READ_IMPLEMENTATION(uint32_t, UInt, 32BE)
 491     TYPED_READ_IMPLEMENTATION(int32_t, Int, 32LE)
 492     TYPED_READ_IMPLEMENTATION(int32_t, Int, 32BE)
 493     TYPED_READ_IMPLEMENTATION(uint64_t, UInt, 64LE)
 494     TYPED_READ_IMPLEMENTATION(uint64_t, UInt, 64BE)
 495     TYPED_READ_IMPLEMENTATION(int64_t, Int, 64LE)
 496     TYPED_READ_IMPLEMENTATION(int64_t, Int, 64BE)
 497
 498     TYPED_READ_IMPLEMENTATION(float, Float, 32LE)
 499     TYPED_READ_IMPLEMENTATION(float, Float, 32BE)
 500     TYPED_READ_IMPLEMENTATION(double, Float, 64LE)
 501     TYPED_READ_IMPLEMENTATION(double, Float, 64BE)
 502
 503 #undef TYPED_READ_IMPLEMENTATION
 504
 505 private:
 506     const RTIData& _value;
 507 };
 508
 509 class HLAEncodeStream : public RTIBasicDataStream {
 510 public:
 511     HLAEncodeStream(RTIData& value) :
 512         _value(value)
 513     { }
 514
 515     bool alignOffsetForSize(unsigned size)
 516     {
 517         _offset = getAlignedOffset(_offset, size);
 518         _value.resize(_offset);
 519         return true;
 520     }
 521
 522     bool skip(unsigned size)
 523     {
 524         _offset += size;
 525         _value.resize(_offset);
 526         return true;
 527     }
 528
 529     bool eof() const
 530     { return _value.size() <= _offset; }
 531
 532     void setData(const RTIData& data)
 533     { _value = data; }
 534
 535 #define TYPED_WRITE_IMPLEMENTATION(type, base, suffix)                  \
 536     bool encode##base##suffix(type value)                               \
 537     {                                                                   \
 538         unsigned nextOffset = _offset + sizeof(type);                   \
 539         _value.resize(nextOffset);                                      \
 540         _value.set##base##suffix(value, _offset);                       \
 541         _offset = nextOffset;                                           \
 542         return true;                                                    \
 543     }
 544
 545     TYPED_WRITE_IMPLEMENTATION(uint8_t, UInt, 8)
 546     TYPED_WRITE_IMPLEMENTATION(int8_t, Int, 8)
 547     TYPED_WRITE_IMPLEMENTATION(uint16_t, UInt, 16LE)
 548     TYPED_WRITE_IMPLEMENTATION(uint16_t, UInt, 16BE)
 549     TYPED_WRITE_IMPLEMENTATION(int16_t, Int, 16LE)
 550     TYPED_WRITE_IMPLEMENTATION(int16_t, Int, 16BE)
 551     TYPED_WRITE_IMPLEMENTATION(uint32_t, UInt, 32LE)
 552     TYPED_WRITE_IMPLEMENTATION(uint32_t, UInt, 32BE)
 553     TYPED_WRITE_IMPLEMENTATION(int32_t, Int, 32LE)
 554     TYPED_WRITE_IMPLEMENTATION(int32_t, Int, 32BE)
 555     TYPED_WRITE_IMPLEMENTATION(uint64_t, UInt, 64LE)
 556     TYPED_WRITE_IMPLEMENTATION(uint64_t, UInt, 64BE)
 557     TYPED_WRITE_IMPLEMENTATION(int64_t, Int, 64LE)
 558     TYPED_WRITE_IMPLEMENTATION(int64_t, Int, 64BE)
 559
 560     TYPED_WRITE_IMPLEMENTATION(float, Float, 32LE)
 561     TYPED_WRITE_IMPLEMENTATION(float, Float, 32BE)
 562     TYPED_WRITE_IMPLEMENTATION(double, Float, 64LE)
 563     TYPED_WRITE_IMPLEMENTATION(double, Float, 64BE)
 564
 565 #undef TYPED_WRITE_IMPLEMENTATION
 566
 567 private:
 568     RTIData& _value;
 569 };
 570
 571 } // namespace simgear
 572
 573 #endif