text: //  loop_time_test.cpp  ----------------------------------------------------------------//
  
  //  Copyright Beman Dawes 2013
  
  //  Distributed under the Boost Software License, Version 1.0.
  //  http://www.boost.org/LICENSE_1_0.txt
  
  //--------------------------------------------------------------------------------------//
  
  //#define BOOST_ENDIAN_NO_INTRINSICS
  
  #include <boost/endian/detail/disable_warnings.hpp>
  
  #include <boost/endian/conversion.hpp>
  #include <boost/endian/arithmetic.hpp>
  #include <boost/cstdint.hpp>
  #include <boost/timer/timer.hpp>
  #include <iostream>
  #include <cstdlib>
  #include <string>
  #include <boost/detail/lightweight_main.hpp>
  
  #ifdef _MSC_VER
  #  pragma warning (push)
  #  pragma warning (disable : 4459)
  #endif
  #include <boost/lexical_cast.hpp>
  #ifdef _MSC_VER
  #  pragma warning (pop)
  #endif
  
  using namespace boost;
  using namespace boost::endian;
  
  using std::cout;
  using std::endl;
  
  namespace
  {
    typedef  boost::timer::nanosecond_type nanosecond_t;
    std::string command_args;
    uint64_t n;                 // number of test cases to run
    int places = 2;             // decimal places for times
    bool verbose (false);
    bool time_aligned (true);
    bool time_unaligned (true);
    bool time_16(true);
    bool time_32(true);
    bool time_64(true);
  
    void process_command_line(int argc, char * argv[])
    {
      for (int a = 0; a < argc; ++a)
      {
        command_args += argv[a];
        if (a != argc-1)
          command_args += ' ';
      }
  
   //   cout << command_args << '\n';;
  
      if (argc >=2)
  #ifndef _MSC_VER
        n = atoll(argv[1]);
  #else
        n = _atoi64(argv[1]);
  #endif
  
      for (; argc > 2; ++argv, --argc)
      {
        if ( *(argv[2]+1) == 'p' )
          places = atoi( argv[2]+2 );
        else if (*(argv[2] + 1) == 'v')
          verbose = true;
        else if (*(argv[2] + 1) == 'a')
          time_unaligned = false;
        else if (*(argv[2] + 1) == 'u')
          time_aligned = false;
        else if (*(argv[2] + 1) == '1')
          time_32 = time_64 = false;
        else if (*(argv[2] + 1) == '3')
          time_16 = time_64 = false;
        else if (*(argv[2] + 1) == '6')
          time_16 = time_32 = false;
        else
        {
          cout << "Error - unknown option: " << argv[2] << "\n\n";
          argc = -1;
          break;
        }
      }
  
      if (argc < 2)
      {
        cout << "Usage: loop_time_test n [Options]\n"
                "  The argument n specifies the number of test cases to run\n"
                "  Options:\n"
                "   -v       Verbose messages\n"
                "   -p#      Decimal places for times; default -p" << places << "\n"
                "   -a       Aligned tests only\n"
                "   -u       Unaligned tests only\n"
                "   -16      16-bit tests only\n"
                "   -32      32-bit tests only\n"
                "   -64      64-bit tests only\n"
                ;
        return std::exit(1);
      }
    }
  
    std::string with_digit_separator(int64_t x)
    {
      std::string s = boost::lexical_cast<std::string>(x);
      std::string s2;
  
      for (std::string::size_type i = 0; i < s.size(); ++i)
      {
        if (i && ((s.size()-i) % 3) == 0)
          s2 += '\'';
        s2 += s[i];
      }
      return s2;
    }
  
  //--------------------------------------------------------------------------------------//
  
    template <class T, class EndianT>
    void time()
    {
      T total = 0;
      {
   //     cout << "*************Endian integer approach...\n";
        EndianT x(0);
        boost::timer::cpu_timer t;
        for (uint64_t i = 0; i < n; ++i)
        {
          x += static_cast<T>(i);
        }
        t.stop();
        total += x;
        cout << "<td align=\"right\">" << t.format(places, "%t") << " s</td>";
      }
      {
  //      cout << "***************Endian conversion approach...\n";
        T x(0);
        boost::timer::cpu_timer t;
        native_to_big_inplace(x);
        for (uint64_t i = 0; i < n; ++i)
        {
          x += static_cast<T>(i);
        }
        big_to_native_inplace(x);
        t.stop();
        native_to_big_inplace(x);
        if (x != total)
          throw std::logic_error("integer approach total != conversion approach total");
        cout << "<td align=\"right\">" << t.format(places, "%t") << " s</td>";
      }
    }
  
  
    void test_big_align_int16()
    {
      cout << "<tr><td>16-bit aligned big endian</td>";
      time<int16_t, big_int16_at>();
      cout << "</tr>\n";
    }
  
    void test_little_align_int16()
    {
      cout << "<tr><td>16-bit aligned little endian</td>";
      time<int16_t, little_int16_at>();
      cout << "</tr>\n";
    }
  
    void test_big_int16()
    {
      cout << "<tr><td>16-bit unaligned big endian</td>";
      time<int16_t, big_int16_t>();
      cout << "</tr>\n";
    }
  
    void test_little_int16()
    {
      cout << "<tr><td>16-bit unaligned little endian</td>";
      time<int16_t, little_int16_t>();
      cout << "</tr>\n";
    }
  
    void test_big_align_int32()
    {
      cout << "<tr><td>32-bit aligned big endian</td>";
      time<int32_t, big_int32_at>();
      cout << "</tr>\n";
    }
  
    void test_little_align_int32()
    {
      cout << "<tr><td>32-bit aligned little endian</td>";
      time<int32_t, little_int32_at>();
      cout << "</tr>\n";
    }
  
    void test_big_int32()
    {
      cout << "<tr><td>32-bit unaligned big endian</td>";
      time<int32_t, big_int32_t>();
      cout << "</tr>\n";
    }
  
    void test_little_int32()
    {
      cout << "<tr><td>32-bit unaligned little endian</td>";
      time<int32_t, little_int32_t>();
      cout << "</tr>\n";
    }
  
    void test_big_align_int64()
    {
      cout << "<tr><td>64-bit aligned big endian</td>";
      time<int64_t, big_int64_at>();
      cout << "</tr>\n";
    }
  
    void test_little_align_int64()
    {
      cout << "<tr><td>64-bit aligned little endian</td>";
      time<int64_t, little_int64_at>();
      cout << "</tr>\n";
    }
  
    void test_big_int64()
    {
      cout << "<tr><td>64-bit unaligned big endian</td>";
      time<int64_t, big_int64_t>();
      cout << "</tr>\n";
    }
  
    void test_little_int64()
    {
      cout << "<tr><td>64-bit unaligned little endian</td>";
      time<int64_t, little_int64_t>();
      cout << "</tr>\n";
    }
  
  }  // unnamed namespace
  
  //--------------------------------------------------------------------------------------//
  
  int cpp_main(int argc, char* argv[])
  {
    process_command_line(argc, argv);
  
    cout
      << "<html>\n<head>\n<title>Endian Loop Time Test</title>\n</head>\n<body>\n"
      << "<!-- boost-no-inspect -->\n"
      << "<div align=\"center\"> <center>\n"
      << "<table border=\"1\" cellpadding=\"5\" cellspacing=\"0\""
      << "style=\"border-collapse: collapse\" bordercolor=\"#111111\">\n"
      << "<tr><td colspan=\"6\" align=\"center\"><b>"
      << BOOST_COMPILER << "</b></td></tr>\n"
      << "<tr><td colspan=\"6\" align=\"center\"><b>"
      << " Iterations: " << with_digit_separator(n)
      << ", Intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG
      << "</b></td></tr>\n"
      << "<tr><td><b>Test Case</b></td>\n"
      "<td align=\"center\"><b>Endian<br>arithmetic<br>type</b></td>\n"
         "<td align=\"center\"><b>Endian<br>conversion<br>function</b></td>\n"
         "</tr>\n"
      ;
  
    if (time_aligned)
    {
      if (time_16)
      {
        test_big_align_int16();
        test_little_align_int16();
      }
      if (time_32)
      {
        test_big_align_int32();
        test_little_align_int32();
      }
      if (time_64)
      {
        test_big_align_int64();
        test_little_align_int64();
      }
    }
  
    if (time_unaligned)
    {
      if (time_16)
      {
        test_big_int16();
        test_little_int16();
      }
      if (time_32)
      {
        test_big_int32();
        test_little_int32();
      }
      if (time_64)
      {
        test_big_int64();
        test_little_int64();
      }
    }
  
    cout << "\n</div> </center>\n"
         << "\n</table>\n</body>\n</html>\n";
  
    return 0;
  }
  
  #include <boost/endian/detail/disable_warnings_pop.hpp>
  