ceph/src/boost/libs/endian/example/use_cases.cpp

   1 //  endian/example/uses_cases.cpp  -----------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 2014
   4
   5 //  Distributed under the Boost Software License, Version 1.0.
   6 //  See http://www.boost.org/LICENSE_1_0.txt
   7
   8 //--------------------------------------------------------------------------------------//
   9
  10 #ifndef _SCL_SECURE_NO_WARNINGS
  11 # define _SCL_SECURE_NO_WARNINGS
  12 #endif
  13
  14 #ifndef _CRT_SECURE_NO_WARNINGS
  15 # define _CRT_SECURE_NO_WARNINGS
  16 #endif
  17
  18
  19 #include <boost/endian/conversion.hpp>
  20 #include <boost/endian/buffers.hpp>
  21 #include <boost/endian/arithmetic.hpp>
  22 #include <iostream>
  23
  24 using namespace boost::endian;
  25
  26 using std::cout;
  27 using std::endl;
  28
  29
  30
  31
  32   { // Use case 2 - Endian buffer types
  33
  34     struct Record
  35     {
  36       big_ubuf32_t count;  // big endian
  37       big_buf32_t  value;  // big endian
  38     };
  39
  40     Record rec;
  41
  42     read(&rec, sizeof(Record));
  43
  44     uint32_t count = rec.count.value();
  45     int32_t value = rec.value.value();
  46
  47     ++count;
  48     value += fee;
  49
  50     rec.count = count;
  51     rec.value = value;
  52
  53     write(&rec, sizeof(Record));
  54   }
  55
  56   { // Use case 3a - Endian arithmetic types
  57
  58     struct Record
  59     {
  60       big_uint32_t count;  // big endian
  61       big_int32_t  value;  // big endian
  62     };
  63
  64     Record rec;
  65
  66     read(&rec, sizeof(Record));
  67
  68     ++rec.count;
  69     rec.value += fee;
  70
  71     write(&rec, sizeof(Record));
  72   }
  73
  74   { // Use case 3b - Endian arithmetic types
  75
  76     struct Record
  77     {
  78       big_uint32_t count;  // big endian
  79       big_int32_t  value;  // big endian
  80     };
  81
  82     Record rec;
  83
  84     read(&rec, sizeof(Record));
  85
  86     uint32_t count = rec.count;
  87     int32_t value = rec.value;
  88
  89     ++count;
  90     value += fee;
  91
  92     rec.count = count;
  93     rec.value = value;
  94
  95     write(&rec, sizeof(Record));
  96   }
  97
  98   //  Recommended approach when conversion time is not a concern
  99   //
 100   //  Conversion time is not a concert with this application because the minimum
 101   //  possible number of conversions is performed and because I/O time will be
 102   //  much greater than conversion time.
 103
 104   {
 105     struct Record
 106     {
 107       big_uint32_t count;  // big endian
 108       big_int32_t  value;  // big endian
 109     };
 110
 111     Record rec;
 112
 113     read(&rec, sizeof(Record));
 114
 115     ++rec.count;
 116     rec.value += fee;
 117
 118     write(&rec, sizeof(Record));
 119   }
 120
 121 //  Recommended approach when conversion time is a concern
 122   //
 123   //  Conversion time is a concert with this application because (1) any conversions
 124   //  performed in the loop will consume a great deal of time and because (2)
 125   //  computation time will be much greater than I/O time.
 126
 127   {
 128     struct Record
 129     {
 130       big_uint32_t count;  // big endian
 131       big_int32_t  value;  // big endian
 132     };
 133
 134     Record rec;
 135
 136     read(&rec, sizeof(Record));
 137
 138     uint32_t count = rec.count;
 139     int32_t value = rec.value;
 140
 141     for (long long i = 0; i < several_gazillion; ++i)  // (1)
 142     {
 143       ... immensely complex computation using rec variables many times // (2)
 144     }
 145
 146     rec.count = count;
 147     rec.value = value;
 148
 149     write(&rec, sizeof(Record));
 150   }
 151
 152 }