VuoArtNetInputDevice.c

Go to the documentation of this file.

 
#include "type.h"
#include "VuoArtNetInputDevice.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                      "title" : "Art-Net Input Device",
                      "description" : "Information about an Art-Net input device.",
                      "keywords" : [ ],
                      "version" : "1.0.0",
                      "dependencies" : [
                          "VuoInteger",
                          "VuoText"
                      ]
                  });
#endif
 
VuoArtNetInputDevice VuoArtNetInputDevice_makeFromJson(json_object * js)
{
    return (VuoArtNetInputDevice){
        VuoJson_getObjectValue(VuoText, js, "name",            NULL),
        VuoJson_getObjectValue(VuoText, js, "ipAddress",       NULL),
        VuoJson_getObjectValue(VuoText, js, "ethernetAddress", NULL),
        {
            VuoJson_getObjectValue(VuoInteger, js, "net",      0),
            VuoJson_getObjectValue(VuoInteger, js, "subNet",   0),
            VuoJson_getObjectValue(VuoInteger, js, "universe", 0),
        }};
}
 
json_object * VuoArtNetInputDevice_getJson(const VuoArtNetInputDevice value)
{
    json_object *js = json_object_new_object();
 
    if (value.name)
        json_object_object_add(js, "name", VuoText_getJson(value.name));
 
    if (value.ipAddress)
        json_object_object_add(js, "ipAddress", VuoText_getJson(value.ipAddress));
 
    if (value.ethernetAddress)
        json_object_object_add(js, "ethernetAddress", VuoText_getJson(value.ethernetAddress));
 
    json_object_object_add(js, "net", VuoInteger_getJson(value.address.net));
 
    json_object_object_add(js, "subNet", VuoInteger_getJson(value.address.subNet));
 
    json_object_object_add(js, "universe", VuoInteger_getJson(value.address.universe));
 
    return js;
}
 
char *VuoArtNetInputDevice_getSummary(const VuoArtNetInputDevice value)
{
    if (value.name && value.ipAddress && value.ethernetAddress)
        return VuoText_format("%s<br>%s (%s)<br>Net %lld, Sub-Net %lld, Universe %lld",
                              value.name,
                              value.ipAddress, value.ethernetAddress,
                              value.address.net, value.address.subNet, value.address.universe);
    else
        return VuoText_format("Net %lld, Sub-Net %lld, Universe %lld", value.address.net, value.address.subNet, value.address.universe);
}
 
VuoArtNetInputDevice VuoArtNetInputDevice_make(const VuoInteger net, const VuoInteger subNet, const VuoInteger universe)
{
    VuoArtNetInputDevice d;
    bzero(&d, sizeof(VuoArtNetInputDevice));
    d.address.net      = MIN(MAX(net,      0), 127);
    d.address.subNet   = MIN(MAX(subNet,   0),  15);
    d.address.universe = MIN(MAX(universe, 0),  15);
    return d;
}
 
bool VuoArtNetInputDevice_areEqual(const VuoArtNetInputDevice value1, const VuoArtNetInputDevice value2)
{
    if (!VuoArtNetAddress_areEqual(value1.address, value2.address))
        return false;
 
    if (!VuoText_areEqual(value1.ipAddress, value2.ipAddress))
        return false;
 
    if (!VuoText_areEqual(value1.name, value2.name))
        return false;
 
    if (!VuoText_areEqual(value1.ethernetAddress, value2.ethernetAddress))
        return false;
 
    return true;
}
 
bool VuoArtNetInputDevice_isLessThan(const VuoArtNetInputDevice a, const VuoArtNetInputDevice b)
{
    VuoType_returnInequality(VuoText,          a.name,            b.name);
    VuoType_returnInequality(VuoText,          a.ipAddress,       b.ipAddress);
    VuoType_returnInequality(VuoText,          a.ethernetAddress, b.ethernetAddress);
    VuoType_returnInequality(VuoArtNetAddress, a.address,         b.address);
    return false;
}
 
bool VuoArtNetAddress_areEqual(const VuoArtNetAddress value1, const VuoArtNetAddress value2)
{
    return value1.net      == value2.net
        && value1.subNet   == value2.subNet
        && value1.universe == value2.universe;
}
 
bool VuoArtNetAddress_isLessThan(const VuoArtNetAddress value1, const VuoArtNetAddress value2)
{
    VuoInteger a1 = (value1.net << 8) + (value1.subNet << 4) + value1.universe;
    VuoInteger a2 = (value2.net << 8) + (value2.subNet << 4) + value2.universe;
 
    return a1 < a2;
}