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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *  A command line based RDM controller
 *  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 <iomanip>
#include <set>
#include <string>
#include <vector>


namespace ola {
namespace rdm {

using ola::messaging::BoolMessageField;
using ola::messaging::GenericMessagePrinter;
using ola::messaging::GroupMessageField;
using ola::messaging::Int16MessageField;
using ola::messaging::Int32MessageField;
using ola::messaging::Int8MessageField;
using ola::messaging::MessagePrinter;
using ola::messaging::StringMessageField;
using ola::messaging::UInt16MessageField;
using ola::messaging::UInt32MessageField;
using ola::messaging::UInt8MessageField;
using ola::messaging::UIDMessageField;
using std::endl;
using std::set;
using std::string;


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


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


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

    void Visit(const 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 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 GroupMessageField*) {
      status_message message;
      m_messages.push_back(message);
    }

  protected:
    void PostStringHook() {
      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 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] << endl;
        } else {
          Stream() << message << 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) {}
    };
    vector<status_message> m_messages;
};


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

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

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

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


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

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


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


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

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


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

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


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

    void Visit(const 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]) << endl;
    }

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

class SlotInfoPrinter: public MessagePrinter {
  public:
    void Visit(const 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 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 GroupMessageField*) {
      slot_info slot;
      m_slot_info.push_back(slot);
    }

  protected:
    void PostStringHook() {
      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 string slot = SlotInfoToString(iter->type, iter->label);

        if (slot.empty()) {
          Stream() << " offset: " <<
            iter->offset << ", type: " << iter->type <<
            ", label: " << iter->label << endl;
        } else {
          Stream() << "Slot offset " << iter->offset << ": " << slot << 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) {}
    };
    vector<slot_info> m_slot_info;
};
}  // namespace rdm
}  // namespace ola
#endif  // INCLUDE_OLA_RDM_RDMMESSAGEPRINTERS_H_