DMXPatch.h

Go to the documentation of this file.

#ifndef _DMXPATCH_H_
#define _DMXPATCH_H_

#pragma once

#include "LumiverseCoreConfig.h"

#include "../Patch.h"
#include "DMXDevicePatch.h"
#include "DMXInterface.h"
#include "../lib/libjson/libjson.h"

#include <iostream>

namespace Lumiverse {

  class DMXPatch : public Patch
  {
  public:
    DMXPatch();

    DMXPatch(const JSONNode data);

    virtual ~DMXPatch();

    virtual void update(set<Device *> devices);

    virtual void init();

    virtual void close();

    virtual JSONNode toJSON();

    virtual string getType() { return "DMXPatch"; }

    virtual void deleteDevice(string id);

    // Gets a mapping of device parameters to addresses for the patch type.
    // This is the full patch map.
    // Entries should look something like "deviceId.paramName -> 1 / 25" (DMX example)
    // virtual map<string, string> getPatchParams();

    // Maps Device IDs to starting addresses.
    // This is a more concise view of the patch map compared to getPatchParams()
    // virtual map<string, string> getPatchIDs();

    // Gets a map of patch data with implementation-defined options.
    // Allows flexible querying of patches with implementation-specific details.
    // virtual map<string, string> getPatchInfo(string opts);

    void assignInterface(DMXInterface* iface, unsigned int universe);

    void assignInterface(string iface, unsigned int universe);

    void removeInterface(unsigned int universe, string id = "");

    bool addInterface(DMXInterface* iface);

    void deleteInterface(string id);

    DMXInterface* getInterface(string id);

    void moveInterface(string id, unsigned int universeFrom, unsigned int universeTo);

    const multimap<string, unsigned int> getInterfaceInfo() { return m_ifacePatch; }

    void patchDevice(Device* device, DMXDevicePatch* patch);

    void patchDevice(string id, DMXDevicePatch* patch);

    DMXDevicePatch* getDevicePatch(string id);

    void addDeviceMap(string id, map<string, patchData> deviceMap);

    void addParameter(string mapId, string paramId, unsigned int address, conversionType type);

    void dumpUniverses();

    void dumpUniverse(unsigned int universe);

    bool setRawData(unsigned int universe, vector<unsigned char> univData);

    size_t sizeOfDeviceMap(string id);

    vector<string> getInterfaceIDs();

  private:
    void loadJSON(const JSONNode data);

    void loadDeviceMaps(const JSONNode data);

    JSONNode deviceMapToJSON(string id, map<string, patchData> data);

    vector<vector<unsigned char> > m_universes;

    multimap<string, unsigned int> m_ifacePatch;

    map<string, DMXInterface*> m_interfaces;

    map<string, DMXDevicePatch*> m_patch;

    map<string, map<string, patchData> > m_deviceMaps;
  };
}

#endif