File content as of revision 4:107c23eb31b6:

#include "OSCData.h"

/*=============================================================================
    CONSTRUCTORS

    overloaded methods for each of the types which will
    set the type flag, the size (in bytes), and the data
=============================================================================*/


OSCData::OSCData(const char * s){
    error = OSC_OK;
    type = 's';
    bytes = (strlen(s) + 1);
    //own the data
    char * mem = (char *) malloc(bytes);
    if (mem == NULL){
        error = ALLOCFAILED;
    } else {
        strcpy(mem, s);
        data.s = mem;
    }
}

OSCData::OSCData(int i){
    error = OSC_OK;
    type = 'i';
    //cast it to an int32
    bytes = sizeof(int32_t);
    int32_t i32 = (int32_t) i;
    data.i = i32;
}


OSCData::OSCData(float f){
    error = OSC_OK;
    type = 'f';
    bytes = sizeof(float);
    data.f = f; 
}

OSCData::OSCData(uint64_t t){
    error = OSC_OK;
    type = 't';
    bytes = sizeof(uint64_t );
    data.l = t;
}
OSCData::OSCData(bool b){
    error = OSC_OK;
    type = b?'T':'F';
    bytes = 0;
}


OSCData::OSCData(double d){
    error = OSC_OK;
    bytes = sizeof(double);
    //if it's not 8 bits it's not a true double
    if (bytes == 8){
        type = 'd';
        data.d = d;
    } else {
        type = 'f';
        data.f = d; 
    }
}

OSCData::OSCData(uint8_t * b, int len){
    error = OSC_OK;
    type = 'b';
    bytes = len + 4;
    //add the size to the front of the blob
    uint32_t len32 = (uint32_t) len;
    //make sure the length is endian-safe
    len32 = BigEndian(len32);
    uint8_t * lenPtr = (uint8_t *) (& len32);
    //own the data
    if(bytes>0)
    {
            
        uint8_t * mem = (uint8_t * ) malloc(bytes);
        if (mem == NULL){
            error = ALLOCFAILED;
        } else {
            //copy over the blob length
            memcpy(mem, lenPtr, 4);
            //copy over the blob data
            memcpy(mem + 4, b, len);
            data.b = mem;
        }
    }
    else
        data.b = 0;
}

OSCData::OSCData (OSCData * datum){
    error = OSC_OK;
    type = datum->type;
    bytes = datum->bytes;
    if (type == 'i' || type == 'f' || type == 'd'|| type == 'y'){
        data = datum->data;
    } else if (type == 's' || type == 'b'){
        //allocate a new peice of memory
        uint8_t * mem = (uint8_t * ) malloc(bytes);
        if (mem == NULL){
            error = ALLOCFAILED;
        } else {
            //copy over the blob length
            memcpy(mem, datum->data.b, bytes);
            data.b = mem;
        }
    }
}

//DESTRUCTOR
OSCData::~OSCData(){
    //if there are no bytes, there is nothing to free
    if (bytes>0){
        //if the data is of type 's' or 'b', need to free that memory
        if (type == 's'){
            free(data.s);
        }else if( type == 'b'){
            free(data.b);
        }
    }
}

//sets just the type as a message placeholder
//no data
OSCData::OSCData(char t){
    error = INVALID_OSC;
    type = t;
    bytes = 0;
}

/*=============================================================================
    GETTERS
 
    perform a safety check to make sure the data type matches the request
    otherwise returns NULL
=============================================================================*/

int32_t OSCData::getInt(){
    if (type == 'i'){
        return data.i;
    } else {
        return NULL;
    }
}
uint64_t OSCData::getTime(){
    if (type == 't'){
        return data.l;
    } else {
        return NULL;
    }
}
float OSCData::getFloat(){
    if (type == 'f'){
        return data.f;
    } else {
        return NULL;
    }
}

double OSCData::getDouble(){
    if (type == 'd'){
        return data.d;
    } else {
        return NULL;
    }
}
bool OSCData::getBoolean(){
    
    return type=='T';
}

int OSCData::getString(char * strBuffer, int length){
    if (type == 's' && bytes <= length){
        strncpy(strBuffer, data.s, bytes);
        return bytes;
    } else {
        return NULL;
    }
}

int OSCData::getBlob(uint8_t * blobBuffer, int length){
    if (type == 'b' && bytes <= length){
        memcpy(blobBuffer, data.b, bytes);
        return bytes;
    } else {
        return NULL;
    }
}