RDMMessagePrinters.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * RDMMessagePrinters.h
 * Write out RDM Messages in a human-readable format.
 * Copyright (C) 2010 Simon Newton
 */

#ifndef INCLUDE_OLA_RDM_RDMMESSAGEPRINTERS_H_
#define INCLUDE_OLA_RDM_RDMMESSAGEPRINTERS_H_

#include <ola/Logging.h>
#include <ola/StringUtils.h>
#include <ola/messaging/MessagePrinter.h>
#include <ola/rdm/PidStore.h>
#include <ola/rdm/RDMHelper.h>
#include <ola/rdm/UID.h>
#include <ola/strings/Format.h>
#include <iomanip>
#include <set>
#include <string>
#include <vector>


namespace ola {
namespace rdm {

class RDMMessagePrinter: public ola::messaging::GenericMessagePrinter {
 public:
 explicit RDMMessagePrinter(unsigned int initial_ident = 0)
 : ola::messaging::GenericMessagePrinter(
 ola::messaging::GenericMessagePrinter::DEFAULT_INDENT,
 initial_ident) {
 }
 protected:
 std::string TransformLabel(const std::string &label) {
 std::string new_label = label;
 ola::CustomCapitalizeLabel(&new_label);
 return new_label;
 }
};


class ProxiedDevicesPrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::UIDMessageField *field) {
 Stream() << field->Value() << std::endl;
 }
};


class StatusMessagePrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::UInt8MessageField *field) {
 if (m_messages.empty()) {
 return;
 }
 m_messages.back().status_type = field->Value();
 m_messages.back().status_type_defined = true;
 }

 void Visit(const ola::messaging::Int16MessageField *field) {
 if (m_messages.empty()) {
 return;
 }
 status_message &message = m_messages.back();
 if (message.int_offset < MAX_INT_FIELDS) {
 message.int16_fields[message.int_offset++] = field->Value();
 }
 }

 void Visit(const ola::messaging::UInt16MessageField *field) {
 if (m_messages.empty()) {
 return;
 }
 status_message &message = m_messages.back();
 if (message.uint_offset < MAX_UINT_FIELDS) {
 message.uint16_fields[message.uint_offset++] = field->Value();
 }
 }

 void Visit(const ola::messaging::GroupMessageField*) {
 status_message message;
 m_messages.push_back(message);
 }

 protected:
 void PostStringHook() {
 std::vector<status_message>::const_iterator iter = m_messages.begin();
 for (; iter != m_messages.end(); ++iter) {
 if (!iter->status_type_defined ||
 iter->uint_offset != MAX_UINT_FIELDS ||
 iter->int_offset != MAX_INT_FIELDS) {
 OLA_WARN << "Invalid status message";
 continue;
 }

 const std::string message = StatusMessageIdToString(
 iter->uint16_fields[1],
 iter->int16_fields[0],
 iter->int16_fields[1]);

 Stream() << StatusTypeToString(iter->status_type) << ": ";
 if (iter->uint16_fields[0]) {
 Stream() << "Sub-device " << iter->uint16_fields[0] << ": ";
 }

 if (message.empty()) {
 Stream() << " message-id: " << iter->uint16_fields[1] << ", data1: "
 << iter->int16_fields[0] << ", data2: "
 << iter->int16_fields[1] << std::endl;
 } else {
 Stream() << message << std::endl;
 }
 }
 }

 private:
 enum { MAX_INT_FIELDS = 2 };
 enum { MAX_UINT_FIELDS = 2 };
 struct status_message {
 public:
 uint16_t uint16_fields[MAX_UINT_FIELDS];
 int16_t int16_fields[MAX_INT_FIELDS];
 uint8_t uint_offset;
 uint8_t int_offset;
 uint8_t status_type;
 bool status_type_defined;

 status_message() : uint_offset(0), int_offset(0), status_type(0),
 status_type_defined(false) {}
 };
 std::vector<status_message> m_messages;
};


class SupportedParamsPrinter: public ola::messaging::MessagePrinter {
 public:
 SupportedParamsPrinter(uint16_t manufacturer_id,
 const RootPidStore *root_store)
 : m_manufacturer_id(manufacturer_id),
 m_root_store(root_store) {}

 void Visit(const ola::messaging::UInt16MessageField *message) {
 m_pids.insert(message->Value());
 }

 protected:
 void PostStringHook() {
 std::set<uint16_t>::const_iterator iter = m_pids.begin();
 for (; iter != m_pids.end(); ++iter) {
 Stream() << " " << ola::strings::ToHex(*iter);
 const PidDescriptor *descriptor = m_root_store->GetDescriptor(
 *iter, m_manufacturer_id);
 if (descriptor) {
 std::string name = descriptor->Name();
 ola::ToLower(&name);
 Stream() << " (" << name << ")";
 }
 Stream() << std::endl;
 }
 }

 private:
 std::set<uint16_t> m_pids;
 uint16_t m_manufacturer_id;
 const RootPidStore *m_root_store;
};


class DeviceInfoPrinter: public ola::messaging::GenericMessagePrinter {
 public:
 void Visit(const ola::messaging::UInt16MessageField *message) {
 const std::string name = message->GetDescriptor()->Name();
 if (name == "product_category") {
 Stream() << TransformLabel(name) << ": "
 << ProductCategoryToString(message->Value()) << std::endl;
 } else {
 ola::messaging::GenericMessagePrinter::Visit(message);
 }
 }

 protected:
 std::string TransformLabel(const std::string &label) {
 std::string new_label = label;
 ola::CustomCapitalizeLabel(&new_label);
 return new_label;
 }
};


class LabelPrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::StringMessageField *message) {
 Stream() << EncodeString(message->Value()) << std::endl;
 }
};


class ProductIdPrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::UInt16MessageField *message) {
 m_product_ids.insert(message->Value());
 }

 void PostStringHook() {
 std::set<uint16_t>::const_iterator iter = m_product_ids.begin();
 for (; iter != m_product_ids.end(); ++iter) {
 Stream() << ProductDetailToString(*iter) << std::endl;
 }
 }

 private:
 std::set<uint16_t> m_product_ids;
};


class LanguageCapabilityPrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::StringMessageField *message) {
 m_languages.insert(message->Value());
 }

 void PostStringHook() {
 std::set<std::string>::const_iterator iter = m_languages.begin();
 for (; iter != m_languages.end(); ++iter) {
 Stream() << EncodeString(*iter) << std::endl;
 }
 }
 private:
 std::set<std::string> m_languages;
};


class ClockPrinter: public ola::messaging::MessagePrinter {
 public:
 ClockPrinter()
 : ola::messaging::MessagePrinter(),
 m_year(0),
 m_offset(0) {}
 void Visit(const ola::messaging::UInt16MessageField *message) {
 m_year = message->Value();
 }

 void Visit(const ola::messaging::UInt8MessageField *message) {
 if (m_offset < CLOCK_FIELDS) {
 m_fields[m_offset] = message->Value();
 }
 m_offset++;
 }

 void PostStringHook() {
 if (m_offset != CLOCK_FIELDS) {
 Stream() << "Malformed packet";
 }
 Stream() << std::setfill('0') << std::setw(2)
 << static_cast<int>(m_fields[1]) << "/"
 << static_cast<int>(m_fields[0]) << "/"
 << m_year << " "
 << static_cast<int>(m_fields[2]) << ":"
 << static_cast<int>(m_fields[3]) << ":"
 << static_cast<int>(m_fields[4]) << std::endl;
 }

 private:
 enum { CLOCK_FIELDS = 5};
 uint16_t m_year;
 uint8_t m_fields[CLOCK_FIELDS];
 unsigned int m_offset;
};

class SlotInfoPrinter: public ola::messaging::MessagePrinter {
 public:
 void Visit(const ola::messaging::UInt8MessageField *field) {
 if (m_slot_info.empty()) {
 return;
 }
 m_slot_info.back().type = field->Value();
 m_slot_info.back().type_defined = true;
 }

 void Visit(const ola::messaging::UInt16MessageField *field) {
 if (m_slot_info.empty()) {
 return;
 }
 if (!m_slot_info.back().offset_defined) {
 m_slot_info.back().offset = field->Value();
 m_slot_info.back().offset_defined = true;
 } else {
 m_slot_info.back().label = field->Value();
 m_slot_info.back().label_defined = true;
 }
 }

 void Visit(const ola::messaging::GroupMessageField*) {
 slot_info slot;
 m_slot_info.push_back(slot);
 }

 protected:
 void PostStringHook() {
 std::vector<slot_info>::const_iterator iter = m_slot_info.begin();
 for (; iter != m_slot_info.end(); ++iter) {
 if (!iter->offset_defined ||
 !iter->type_defined ||
 !iter->label_defined) {
 OLA_WARN << "Invalid slot info";
 continue;
 }

 const std::string slot = SlotInfoToString(iter->type, iter->label);

 if (slot.empty()) {
 Stream() << " offset: " << iter->offset << ", type: " << iter->type
 << ", label: " << iter->label << std::endl;
 } else {
 Stream() << "Slot offset " << iter->offset << ": " << slot << std::endl;
 }
 }
 }

 private:
 struct slot_info {
 public:
 uint16_t offset;
 bool offset_defined;
 uint8_t type;
 bool type_defined;
 uint16_t label;
 bool label_defined;

 slot_info() : offset(0), offset_defined(false), type(0),
 type_defined(false), label(0), label_defined(false) {}
 };
 std::vector<slot_info> m_slot_info;
};


class SensorDefinitionPrinter: public ola::messaging::GenericMessagePrinter {
 public:
 void Visit(const ola::messaging::UInt8MessageField *message) {
 const std::string name = message->GetDescriptor()->Name();
 if (name == "type") {
 Stream() << TransformLabel(name) << ": "
 << SensorTypeToString(message->Value()) << std::endl;
 } else if (name == "unit") {
 Stream() << TransformLabel(name) << ": ";
 if (message->Value() == UNITS_NONE) {
 Stream() << "None";
 } else {
 Stream() << UnitToString(message->Value());
 }
 Stream() << std::endl;
 } else if (name == "prefix") {
 Stream() << TransformLabel(name) << ": ";
 if (message->Value() == PREFIX_NONE) {
 Stream() << "None";
 } else {
 Stream() << PrefixToString(message->Value());
 }
 Stream() << std::endl;
 } else if (name == "supports_recording") {
 Stream() << TransformLabel(name) << ": ";
 std::string supports_recording =
 SensorSupportsRecordingToString(message->Value());
 if (supports_recording.empty()) {
 Stream() << "None";
 } else {
 Stream() << supports_recording;
 }
 Stream() << std::endl;
 } else {
 ola::messaging::GenericMessagePrinter::Visit(message);
 }
 }

 protected:
 std::string TransformLabel(const std::string &label) {
 std::string new_label = label;
 ola::CustomCapitalizeLabel(&new_label);
 return new_label;
 }
};
} // namespace rdm
} // namespace ola
#endif // INCLUDE_OLA_RDM_RDMMESSAGEPRINTERS_H_