Fix some more issues

common/rdm/RDMHelper.cpp

@@ -994,15 +994,15 @@ string StatusMessageIdToString(uint16_t message_id,
       // Data Value shall be a signed integer." but I'm sure it's what was
       // intended. The same thing is technically true with the slots too.
       str << "Proxy Drop: PID "
-          << IntToHexString(reinterpret_cast<uint16_t&>(data1)) << " at TN "
+          << ToHex(reinterpret_cast<uint16_t&>(data1)) << " at TN "
           << data2;
       break;
     case STS_ASC_RXOK:
-      str << "DMX ASC " << IntToHexString(reinterpret_cast<uint16_t&>(data1))
+      str << "DMX ASC " << ToHex(reinterpret_cast<uint16_t&>(data1))
           << " received OK";
       break;
     case STS_ASC_DROPPED:
-      str << "DMX ASC " << IntToHexString(reinterpret_cast<uint16_t&>(data1))
+      str << "DMX ASC " << ToHex(reinterpret_cast<uint16_t&>(data1))
           << " now dropped";
       break;
     case STS_DMXNSCNONE:

common/utils/DmxBuffer.cpp

@@ -238,7 +238,7 @@ void DmxBuffer::SetChannel(unsigned int channel, uint8_t data) {
   }
 
   if (channel > m_length) {
-    OLA_WARN << "attempting to set channel " << channel << " when length is "
+    OLA_WARN << "Attempting to set channel " << channel << " when length is "
              << m_length;
     return;
   }

common/utils/StringUtils.cpp

@@ -122,10 +122,11 @@ string IntToString(unsigned int i) {
 }
 
 string IntToHexString(unsigned int i, unsigned int width) {
+  _ToHex<unsigned int> v = _ToHex<unsigned int>(i,
+                                                static_cast<int>(width),
+                                                true);
   ostringstream str;
-  // In C++, you only get the 0x on non-zero values, so we have to explicitly
-  // add it for all values
-  str << "0x" << std::setw(width) << std::hex << std::setfill('0') << i;
+  str << v;
   return str.str();
 }
 
@@ -397,6 +398,7 @@ void CapitalizeLabel(string *s) {
   for (string::iterator iter = s->begin(); iter != s->end(); ++iter) {
     switch (*iter) {
       case '-':
+        // fall through, also convert to space
       case '_':
         *iter = ' ';
       case ' ':

common/utils/StringUtilsTest.cpp

@@ -52,6 +52,8 @@ using ola::StripPrefix;
 using ola::StripSuffix;
 using ola::ToLower;
 using ola::ToUpper;
+using ola::ToHex;
+using std::ostringstream;
 using std::string;
 using std::vector;
 
@@ -313,6 +315,7 @@ void StringUtilsTest::testIntToString() {
  * test the IntToHexString function.
  */
 void StringUtilsTest::testIntToHexString() {
+  // Using the old IntToHexString
   OLA_ASSERT_EQ(string("0x00"), IntToHexString((uint8_t)0));
 
   OLA_ASSERT_EQ(string("0x01"), IntToHexString((uint8_t)1));
@@ -323,6 +326,45 @@ void StringUtilsTest::testIntToHexString() {
 
   unsigned int i = 0x42;
   OLA_ASSERT_EQ(string("0x00000042"), IntToHexString(i));
+
+  // Using the inline string concatenation
+  ostringstream str;
+  str << ToHex((uint8_t)0);
+  OLA_ASSERT_EQ(string("0x00"), str.str());
+  str.str("");
+
+  str << ToHex((uint8_t)1);
+  OLA_ASSERT_EQ(string("0x01"), str.str());
+  str.str("");
+
+  str << ToHex((uint8_t)0x42);
+  OLA_ASSERT_EQ(string("0x42"), str.str());
+  str.str("");
+
+  str << ToHex((uint16_t)0x0001);
+  OLA_ASSERT_EQ(string("0x0001"), str.str());
+  str.str("");
+
+  str << ToHex((uint16_t)0xABCD);
+  OLA_ASSERT_EQ(string("0xabcd"), str.str());
+  str.str("");
+
+  str << ToHex((uint32_t)0xDEADBEEF);
+  OLA_ASSERT_EQ(string("0xdeadbeef"), str.str());
+  str.str("");
+
+  str << ToHex(i);
+  OLA_ASSERT_EQ(string("0x00000042"), str.str());
+  str.str("");
+
+  // Without prefix
+  str << ToHex((uint8_t)0x42, false);
+  OLA_ASSERT_EQ(string("42"), str.str());
+  str.str("");
+
+  str << ToHex((uint16_t)0xABCD, false);
+  OLA_ASSERT_EQ(string("abcd"), str.str());
+  str.str("");
 }
 
 

examples/ola-dmxconsole.cpp

@@ -445,6 +445,7 @@ void changepalette(int p) {
   switch (p) {
     default:
       palette_number = 0;
+      // fall through, use 0 as default palette
     case 0:
       init_pair(CHANNEL, COLOR_BLACK, COLOR_CYAN);
       init_pair(ZERO, COLOR_BLACK, COLOR_WHITE);

examples/ola-dmxmonitor.cpp

@@ -559,6 +559,7 @@ void DmxMonitor::ChangePalette(int p) {
   switch (p) {
     default:
       m_palette_number = 0;
+      // fall through, use 0 as default palette
     case 0:
       init_pair(CHANNEL, COLOR_BLACK, COLOR_CYAN);
       init_pair(ZERO, COLOR_BLACK, COLOR_WHITE);

examples/ola-rdm.cpp

@@ -24,6 +24,7 @@
 #include <ola/Logging.h>
 #include <ola/OlaCallbackClient.h>
 #include <ola/OlaClientWrapper.h>
+#include <ola/StringUtils.h>
 #include <ola/base/Init.h>
 #include <ola/base/SysExits.h>
 #include <ola/file/Util.h>
@@ -308,8 +309,8 @@ void RDMController::HandleResponse(
     cout << "Request NACKed: " <<
       ola::rdm::NackReasonToString(response_status.NackReason()) << endl;
   } else {
-    cout << "Unknown RDM response type " << std::hex <<
-        static_cast<int>(response_status.response_type) << endl;
+    cout << "Unknown RDM response type "
+         << ola::ToHex(response_status.response_type) << endl;
   }
   PrintRemainingMessages(response_status.message_count);
   m_ola_client.GetSelectServer()->Terminate();

include/ola/StringUtils.h

@@ -27,7 +27,10 @@
 #define INCLUDE_OLA_STRINGUTILS_H_
 
 #include <stdint.h>
+#include <iomanip>
+#include <iostream>
 #include <limits>
+#include <ostream>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -108,44 +111,109 @@ std::string IntToString(int i);
  */
 std::string IntToString(unsigned int i);
 
+/**
+ * Internal type used by ToHex
+ */
+template<typename T>
+struct _ToHex {
+ public:
+  _ToHex(T v, int width, bool prefix)
+      : width(width),
+        value(v),
+        prefix(prefix) {
+  }
+
+  int width;  // setw takes an int
+  T value;
+  bool prefix;
+};
+
+inline uint32_t _HexCast(uint8_t v) { return v; }
+inline uint16_t _HexCast(uint16_t v) { return v; }
+inline uint32_t _HexCast(uint32_t v) { return v; }
+
+/**
+ * Convert a value to a hex string.
+ *
+ * Automatic constructor for _ToHex that deals with widths
+ * @tparam T the type of value to convert
+ * @param v the value to convert
+ * @param prefix show the 0x prefix
+ * @return A _ToHex struct representing the value, output it to an ostream to
+ *     use it.
+ * @note We only currently support unsigned ints due to a lack of requirement
+ * for anything else
+ */
+template<typename T>
+_ToHex<T> ToHex(T v, bool prefix = true) {
+  return _ToHex<T>(v,
+                   (std::numeric_limits<T>::digits / HEX_BIT_WIDTH),
+                   prefix);
+}
+
+/**
+ * Output the _ToHex type to an ostream
+ */
+template <typename T>
+std::ostream& operator<<(std::ostream &out, const _ToHex<T> &i) {
+  // In C++, you only get the 0x on non-zero values, so we have to explicitly
+  // add it for all values if we want it
+  if (i.prefix) {
+    out << "0x";
+  }
+  return out << std::setw(i.width) << std::hex << std::setfill('0')
+             << _HexCast(i.value) << std::dec;
+}
+
 /**
  * Convert an unsigned int to a hex string.
  * @param i the unsigned int to convert
  * @param width the width to zero pad to
  * @return The hex string representation of the unsigned int
  * @note We don't currently support signed ints due to a lack of requirement
  * for it and issues with negative handling and hex in C++
+ * @deprecated ola::ToHex() instead, unless you really want a string rather
+ *   than use in an ostream (30 Dec 2014)
  */
 std::string IntToHexString(unsigned int i, unsigned int width);
 
 /**
  * Convert a uint8_t to a hex string.
  * @param i the number to convert
  * @return The string representation of the number
+ * @deprecated ola::ToHex() instead, unless you really want a string rather
+ *   than use in an ostream (30 Dec 2014)
  */
 inline std::string IntToHexString(uint8_t i) {
-  return IntToHexString(i, (std::numeric_limits<uint8_t>::digits /
-                            HEX_BIT_WIDTH));
+  std::ostringstream str;
+  str << ToHex(i);
+  return str.str();
 }
 
 /**
  * Convert a uint16_t to a hex string.
  * @param i the number to convert
  * @return The string representation of the number
+ * @deprecated ola::ToHex() instead, unless you really want a string rather
+ *   than use in an ostream (30 Dec 2014)
  */
 inline std::string IntToHexString(uint16_t i) {
-  return IntToHexString(i, (std::numeric_limits<uint16_t>::digits /
-                            HEX_BIT_WIDTH));
+  std::ostringstream str;
+  str << ToHex(i);
+  return str.str();
 }
 
 /**
  * Convert a uint32_t to a hex string.
  * @param i the number to convert
  * @return The string representation of the number
+ * @deprecated ola::ToHex() instead, unless you really want a string rather
+ *   than use in an ostream (30 Dec 2014)
  */
 inline std::string IntToHexString(uint32_t i) {
-  return IntToHexString(i, (std::numeric_limits<uint32_t>::digits /
-                            HEX_BIT_WIDTH));
+  std::ostringstream str;
+  str << ToHex(i);
+  return str.str();
 }
 
 /**

plugins/pathport/PathportPort.h

@@ -79,9 +79,9 @@ class PathportOutputPort: public BasicOutputPort {
       return m_helper.Description(GetUniverse());
     }
     bool WriteDMX(const DmxBuffer &buffer, uint8_t priority);
-    bool PreSetUniverse(Universe *old_universe, Universe *new_universe) {
+    bool PreSetUniverse(OLA_UNUSED Universe *old_universe,
+                        Universe *new_universe) {
       return m_helper.PreSetUniverse(new_universe);
-      (void) old_universe;
     }
 
  private:

plugins/usbdmx/AsyncPluginImpl.cpp

@@ -267,8 +267,8 @@ bool AsyncPluginImpl::USBDeviceAdded(libusb_device *usb_device) {
   libusb_get_device_descriptor(usb_device, &descriptor);
 
   OLA_DEBUG << "USB device added, checking for widget support, vendor "
-            << IntToHexString(descriptor.idVendor) << ", product "
-            << IntToHexString(descriptor.idProduct);
+            << ToHex(descriptor.idVendor) << ", product "
+            << ToHex(descriptor.idProduct);
 
   WidgetFactories::iterator iter = m_widget_factories.begin();
   for (; iter != m_widget_factories.end(); ++iter) {

plugins/usbdmx/ScanlimeFadecandy.cpp

@@ -132,9 +132,9 @@ bool InitializeWidget(LibUsbAdaptor *adaptor,
       unsigned int entry = (channel * 257) + value;
       unsigned int packet_entry = entry % 31;
       OLA_DEBUG << "Working on channel " << channel << " value " << value
-                << " (" << IntToHexString(value) << ") with entry " << entry
+                << " (" << ToHex(value) << ") with entry " << entry
                 << ", packet entry " << packet_entry << " with val "
-                << IntToHexString(lut[channel][value]);
+                << ToHex(lut[channel][value]);
       ola::utils::SplitUInt16(lut[channel][value],
                               &packet.data[packet_entry + 1],
                               &packet.data[packet_entry]);

plugins/usbdmx/SyncPluginImpl.cpp

@@ -165,8 +165,8 @@ bool SyncPluginImpl::CheckDevice(libusb_device *usb_device) {
   libusb_get_device_descriptor(usb_device, &device_descriptor);
 
   OLA_DEBUG << "USB device found, checking for widget support, vendor "
-            << IntToHexString(device_descriptor.idVendor) << ", product "
-            << IntToHexString(device_descriptor.idProduct);
+            << ToHex(device_descriptor.idVendor) << ", product "
+            << ToHex(device_descriptor.idProduct);
 
   pair<uint8_t, uint8_t> bus_dev_id(libusb_get_bus_number(usb_device),
                                     libusb_get_device_address(usb_device));

plugins/usbpro/ArduinoRGBDevice.cpp

@@ -71,7 +71,7 @@ ArduinoRGBOutputPort::ArduinoRGBOutputPort(ArduinoRGBDevice *parent,
       m_bucket(initial_count, rate, rate, *wake_time),
       m_wake_time(wake_time) {
   std::ostringstream str;
-  str << "Serial #: " << ola::IntToHexString(serial);
+  str << "Serial #: " << ola::ToHex(serial);
   m_description = str.str();
 }
 }  // namespace usbpro