Message.h

/*
 * 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
 *
 * Message.h
 * Holds the data for a message.
 * Copyright (C) 2011 Simon Newton
 */

#ifndef INCLUDE_OLA_MESSAGING_MESSAGE_H_
#define INCLUDE_OLA_MESSAGING_MESSAGE_H_

#include <ola/messaging/Descriptor.h>
#include <ola/messaging/MessageVisitor.h>
#include <ola/network/IPV4Address.h>
#include <ola/rdm/UID.h>
#include <string>
#include <vector>

using std::string;
using std::vector;


namespace ola {
namespace messaging {


class MessageVisitor;

class Message {
  public:
    explicit Message(const vector<const class MessageFieldInterface*> &fields)
        : m_fields(fields) {
    }
    ~Message();

    void Accept(MessageVisitor *visitor) const;

    unsigned int FieldCount() const { return m_fields.size(); }

  private:
    vector<const class MessageFieldInterface*> m_fields;
};



class MessageFieldInterface {
  public:
    virtual ~MessageFieldInterface() {}

    // Call back into a MessageVisitor
    virtual void Accept(MessageVisitor *visitor) const = 0;
};



class BoolMessageField: public MessageFieldInterface {
  public:
    BoolMessageField(const BoolFieldDescriptor *descriptor,
                      bool value)
        : m_descriptor(descriptor),
          m_value(value) {
    }

    const BoolFieldDescriptor *GetDescriptor() const {
      return m_descriptor;
    }
    bool Value() const { return m_value; }

    void Accept(MessageVisitor *visitor) const {
      visitor->Visit(this);
    }

  private:
    const BoolFieldDescriptor *m_descriptor;
    bool m_value;
};


class IPV4MessageField: public MessageFieldInterface {
  public:
    IPV4MessageField(const IPV4FieldDescriptor *descriptor,
                     const ola::network::IPV4Address &value)
        : m_descriptor(descriptor),
          m_value(value) {
    }

    IPV4MessageField(const IPV4FieldDescriptor *descriptor,
                     uint32_t value)
        : m_descriptor(descriptor),
          m_value(ola::network::IPV4Address(value)) {
    }

    const IPV4FieldDescriptor *GetDescriptor() const {
      return m_descriptor;
    }
    ola::network::IPV4Address Value() const { return m_value; }

    void Accept(MessageVisitor *visitor) const {
      visitor->Visit(this);
    }

  private:
    const IPV4FieldDescriptor *m_descriptor;
    ola::network::IPV4Address m_value;
};


class UIDMessageField: public MessageFieldInterface {
  public:
    UIDMessageField(const UIDFieldDescriptor *descriptor,
                    const ola::rdm::UID &uid)
        : m_descriptor(descriptor),
          m_uid(uid) {
    }

    const UIDFieldDescriptor *GetDescriptor() const {
      return m_descriptor;
    }
    const ola::rdm::UID& Value() const { return m_uid; }

    void Accept(MessageVisitor *visitor) const {
      visitor->Visit(this);
    }

  private:
    const UIDFieldDescriptor *m_descriptor;
    ola::rdm::UID m_uid;
};


class StringMessageField: public MessageFieldInterface {
  public:
    StringMessageField(const StringFieldDescriptor *descriptor,
                       const string &value)
        : m_descriptor(descriptor),
          m_value(value) {
    }

    const StringFieldDescriptor *GetDescriptor() const { return m_descriptor; }
    const string& Value() const { return m_value; }

    void Accept(MessageVisitor *visitor) const {
      visitor->Visit(this);
    }

  private:
    const StringFieldDescriptor *m_descriptor;
    const string m_value;
};


template <typename type>
class BasicMessageField: public MessageFieldInterface {
  public:
    BasicMessageField(const IntegerFieldDescriptor<type> *descriptor,
                      type value)
        : m_descriptor(descriptor),
          m_value(value) {
    }

    const IntegerFieldDescriptor<type> *GetDescriptor() const {
      return m_descriptor;
    }
    type Value() const { return m_value; }

    void Accept(MessageVisitor *visitor) const {
      visitor->Visit(this);
    }

  private:
    const IntegerFieldDescriptor<type> *m_descriptor;
    type m_value;
};


typedef BasicMessageField<uint8_t> UInt8MessageField;
typedef BasicMessageField<uint16_t> UInt16MessageField;
typedef BasicMessageField<uint32_t> UInt32MessageField;
typedef BasicMessageField<int8_t> Int8MessageField;
typedef BasicMessageField<int16_t> Int16MessageField;
typedef BasicMessageField<int32_t> Int32MessageField;


class GroupMessageField: public MessageFieldInterface {
  public:
    GroupMessageField(const FieldDescriptorGroup *descriptor,
                      const vector<const class MessageFieldInterface*> &fields)
      : m_descriptor(descriptor),
        m_fields(fields) {
    }
    ~GroupMessageField();

    const FieldDescriptorGroup *GetDescriptor() const { return m_descriptor; }

    unsigned int FieldCount() const { return m_fields.size(); }
    const class MessageFieldInterface *GetField(unsigned int index) const {
      if (index < m_fields.size())
        return m_fields[index];
      return NULL;
    }

    void Accept(MessageVisitor *visitor) const;

  private:
    const FieldDescriptorGroup *m_descriptor;
    vector<const class MessageFieldInterface*> m_fields;
};
}  // namespace messaging
}  // namespace ola

#endif  // INCLUDE_OLA_MESSAGING_MESSAGE_H_