DMPAddress.h

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * DMPAddress.h
 * Defines the DMP property address types
 * Copyright (C) 2007 Simon Newton
 */

#ifndef PLUGINS_E131_E131_DMPADDRESS_H_
#define PLUGINS_E131_E131_DMPADDRESS_H_

#include <stdint.h>
#include <string.h>
#include "ola/io/OutputStream.h"
#include "ola/network/NetworkUtils.h"

namespace ola {
namespace plugin {
namespace e131 {

using ola::network::HostToNetwork;

typedef enum {
 ONE_BYTES = 0x00,
 TWO_BYTES = 0x01,
 FOUR_BYTES = 0x02,
 RES_BYTES = 0x03
} dmp_address_size;


typedef enum {
 NON_RANGE = 0x00,
 RANGE_SINGLE = 0x01,
 RANGE_EQUAL = 0x02,
 RANGE_MIXED = 0x03,
} dmp_address_type;


static const unsigned int MAX_TWO_BYTE = 0xffff;
static const unsigned int MAX_ONE_BYTE = 0xff;


/*
 * Return the dmp_address_size that corresponds to a type
 */
template <typename type>
dmp_address_size TypeToDMPSize() {
 switch (sizeof(type)) {
 case 1:
 return ONE_BYTES;
 case 2:
 return TWO_BYTES;
 case 4:
 return FOUR_BYTES;
 default:
 return RES_BYTES;
 }
}


/*
 * Return the number of bytes that correspond to a DMPType
 */
unsigned int DMPSizeToByteSize(dmp_address_size size);


/*
 * The Base DMPAddress class.
 * The addresses represented by this class may be actual or virtual & relative
 * or absolute, ranged or non-ranged.
 */
class BaseDMPAddress {
 public:
 BaseDMPAddress() {}
 virtual ~BaseDMPAddress() {}

 // The start address
 virtual unsigned int Start() const = 0;
 // The increment
 virtual unsigned int Increment() const = 0;
 // The number of properties referenced
 virtual unsigned int Number() const = 0;

 // Size of this address structure
 virtual unsigned int Size() const {
 return (IsRange() ? 3 : 1) * BaseSize();
 }

 virtual dmp_address_size AddressSize() const = 0;

 // Pack this address into memory
 virtual bool Pack(uint8_t *data, unsigned int *length) const = 0;

 // Write this address to an OutputStream
 virtual void Write(ola::io::OutputStream *stream) const = 0;

 // True if this is a range address.
 virtual bool IsRange() const = 0;

 protected:
 virtual unsigned int BaseSize() const = 0;
};


/*
 * These type of addresses only reference one property.
 */
template<typename type>
class DMPAddress: public BaseDMPAddress {
 public:
 explicit DMPAddress(type start):
 BaseDMPAddress(),
 m_start(start) {}

 unsigned int Start() const { return m_start; }
 unsigned int Increment() const { return 0; }
 unsigned int Number() const { return 1; }
 dmp_address_size AddressSize() const { return TypeToDMPSize<type>(); }

 bool Pack(uint8_t *data, unsigned int *length) const {
 if (*length < Size()) {
 *length = 0;
 return false;
 }
 type field = HostToNetwork(m_start);
 memcpy(data, &field, BaseSize());
 *length = Size();
 return true;
 }

 void Write(ola::io::OutputStream *stream) const {
 *stream << HostToNetwork(m_start);
 }

 bool IsRange() const { return false; }

 protected:
 unsigned int BaseSize() const { return sizeof(type); }

 private:
 type m_start;
};


typedef DMPAddress<uint8_t> OneByteDMPAddress;
typedef DMPAddress<uint16_t> TwoByteDMPAddress;
typedef DMPAddress<uint32_t> FourByteDMPAddress;

/*
 * Create a new single address
 */
const BaseDMPAddress *NewSingleAddress(unsigned int value);


/*
 * These type of addresses reference multiple properties.
 */
template <typename type>
class RangeDMPAddress: public BaseDMPAddress {
 public:
 RangeDMPAddress(type start,
 type increment,
 type number):
 BaseDMPAddress(),
 m_start(start),
 m_increment(increment),
 m_number(number) {}
 unsigned int Start() const { return m_start; }
 unsigned int Increment() const { return m_increment; }
 unsigned int Number() const { return m_number; }
 dmp_address_size AddressSize() const { return TypeToDMPSize<type>(); }

 bool Pack(uint8_t *data, unsigned int *length) const {
 if (*length < Size()) {
 *length = 0;
 return false;
 }
 type field[3];
 field[0] = HostToNetwork(m_start);
 field[1] = HostToNetwork(m_increment);
 field[2] = HostToNetwork(m_number);
 memcpy(data, &field, Size());
 *length = Size();
 return true;
 }

 void Write(ola::io::OutputStream *stream) const {
 type field[3];
 field[0] = HostToNetwork(m_start);
 field[1] = HostToNetwork(m_increment);
 field[2] = HostToNetwork(m_number);
 stream->Write(reinterpret_cast<uint8_t*>(&field), Size());
 }

 bool IsRange() const { return true; }

 protected:
 unsigned int BaseSize() const { return sizeof(type); }

 private:
 type m_start, m_increment, m_number;
};


typedef RangeDMPAddress<uint8_t> OneByteRangeDMPAddress;
typedef RangeDMPAddress<uint16_t> TwoByteRangeDMPAddress;
typedef RangeDMPAddress<uint32_t> FourByteRangeDMPAddress;


/*
 * Create a new range address.
 */
const BaseDMPAddress *NewRangeAddress(unsigned int value,
 unsigned int increment,
 unsigned int number);

/*
 * Decode an Address
 */
const BaseDMPAddress *DecodeAddress(dmp_address_size size,
 dmp_address_type type,
 const uint8_t *data,
 unsigned int &length);


/*
 * A DMPAddressData object, this hold an address/data pair
 * @param type either DMPAddress<> or RangeDMPAddress<>
 */
template <typename type>
class DMPAddressData {
 public:
 DMPAddressData(const type *address,
 const uint8_t *data,
 unsigned int length):
 m_address(address),
 m_data(data),
 m_length(length) {}

 const type *Address() const { return m_address; }
 const uint8_t *Data() const { return m_data; }
 unsigned int Size() const { return m_address->Size() + m_length; }

 // Pack the data into a buffer
 bool Pack(uint8_t *data, unsigned int *length) const {
 if (!m_data)
 return false;

 unsigned int total = *length;
 if (!m_address->Pack(data, length)) {
 length = 0;
 return false;
 }
 if (total - *length < m_length) {
 length = 0;
 return false;
 }
 memcpy(data + *length, m_data, m_length);
 *length += m_length;
 return true;
 }

 void Write(ola::io::OutputStream *stream) const {
 if (!m_data)
 return;

 m_address->Write(stream);
 stream->Write(m_data, m_length);
 }

 private:
 const type *m_address;
 const uint8_t *m_data;
 unsigned int m_length;
};
} // namespace e131
} // namespace plugin
} // namespace ola
#endif // PLUGINS_E131_E131_DMPADDRESS_H_