PidStore.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
 *
 * PidStore.h
 * Holds information about RDM PIDs.
 * Copyright (C) 2011 Simon Newton
 */

#ifndef INCLUDE_OLA_RDM_PIDSTORE_H_
#define INCLUDE_OLA_RDM_PIDSTORE_H_

#include <stdint.h>
#include <ola/messaging/Descriptor.h>
#include <ola/base/Macro.h>
#include <istream>
#include <map>
#include <memory>
#include <string>
#include <vector>

namespace ola {
namespace rdm {

class PidStore;
class PidDescriptor;

// The following % before Device is to stop Doxygen interpretting it as a class
class RootPidStore {
 public:
 typedef std::map<uint16_t, const PidStore*> ManufacturerMap;

 RootPidStore(const PidStore *esta_store,
 const ManufacturerMap &manufacturer_stores,
 uint64_t version = 0)
 : m_esta_store(esta_store),
 m_manufacturer_store(manufacturer_stores),
 m_version(version) {
 }

 ~RootPidStore();

 uint64_t Version() const { return m_version; }

 const PidStore *EstaStore() const {
 return m_esta_store.get();
 }

 const PidStore *ManufacturerStore(uint16_t esta_id) const;

 const PidDescriptor *GetDescriptor(const std::string &pid_name) const;

 const PidDescriptor *GetDescriptor(const std::string &pid_name,
 uint16_t manufacturer_id) const;

 const PidDescriptor *GetDescriptor(uint16_t pid_value) const;

 const PidDescriptor *GetDescriptor(uint16_t pid_value,
 uint16_t manufacturer_id) const;

 static const RootPidStore *LoadFromFile(const std::string &file,
 bool validate = true);

 static const RootPidStore *LoadFromDirectory(const std::string &directory,
 bool validate = true);

 static const std::string DataLocation();

 private:
 std::auto_ptr<const PidStore> m_esta_store;
 ManufacturerMap m_manufacturer_store;
 uint64_t m_version;

 const PidDescriptor *InternalESTANameLookup(
 const std::string &pid_name) const;

 DISALLOW_COPY_AND_ASSIGN(RootPidStore);
};


class PidStore {
 public:
 explicit PidStore(const std::vector<const PidDescriptor*> &pids);

 ~PidStore();

 unsigned int PidCount() const { return m_pid_by_value.size(); }

 void AllPids(std::vector<const PidDescriptor*> *pids) const;

 const PidDescriptor *LookupPID(uint16_t pid_value) const;

 const PidDescriptor *LookupPID(const std::string &pid_name) const;

 private:
 typedef std::map<uint16_t, const PidDescriptor*> PidMap;
 typedef std::map<std::string, const PidDescriptor*> PidNameMap;
 PidMap m_pid_by_value;
 PidNameMap m_pid_by_name;

 DISALLOW_COPY_AND_ASSIGN(PidStore);
};


class PidDescriptor {
 public:
 // TODO(simon): use the enums from the Pids.proto instead of duplicating
 // here.
 typedef enum {
 ROOT_DEVICE, // 0 only
 ANY_SUB_DEVICE, // 0 - 512 or ALL_DEVICES
 NON_BROADCAST_SUB_DEVICE, // 0 - 512
 SPECIFIC_SUB_DEVICE, // 1- 512
 } sub_device_validator;

 PidDescriptor(const std::string &name,
 uint16_t value,
 const ola::messaging::Descriptor *get_request,
 const ola::messaging::Descriptor *get_response,
 const ola::messaging::Descriptor *set_request,
 const ola::messaging::Descriptor *set_response,
 sub_device_validator get_sub_device_range,
 sub_device_validator set_sub_device_range)
 : m_name(name),
 m_pid_value(value),
 m_get_request(get_request),
 m_get_response(get_response),
 m_set_request(set_request),
 m_set_response(set_response),
 m_get_subdevice_range(get_sub_device_range),
 m_set_subdevice_range(set_sub_device_range) {
 }
 ~PidDescriptor();

 const std::string &Name() const { return m_name; }
 uint16_t Value() const { return m_pid_value; }
 const ola::messaging::Descriptor *GetRequest() const { return m_get_request; }
 const ola::messaging::Descriptor *GetResponse() const {
 return m_get_response;
 }
 const ola::messaging::Descriptor *SetRequest() const { return m_set_request; }
 const ola::messaging::Descriptor *SetResponse() const {
 return m_set_response;
 }

 bool IsGetValid(uint16_t sub_device) const;
 bool IsSetValid(uint16_t sub_device) const;

 private:
 const std::string m_name;
 uint16_t m_pid_value;
 const ola::messaging::Descriptor *m_get_request;
 const ola::messaging::Descriptor *m_get_response;
 const ola::messaging::Descriptor *m_set_request;
 const ola::messaging::Descriptor *m_set_response;
 sub_device_validator m_get_subdevice_range;
 sub_device_validator m_set_subdevice_range;

 bool RequestValid(uint16_t sub_device,
 const sub_device_validator &validator) const;

 DISALLOW_COPY_AND_ASSIGN(PidDescriptor);
};
} // namespace rdm
} // namespace ola
#endif // INCLUDE_OLA_RDM_PIDSTORE_H_