/* Adds an element to a list - Duplicates are not allowed.
* Return: EPHIDGET_OK on success
* EPHIDGET_DUPLICATE if the element already exists in the list
*/
int CList_addToList(CListHandle *list, void *element,
int (*compare_fptr)(void *element1, void *element2))
{
int result = 0;
CListHandle trav = 0, newentry = 0;
TESTPTRS(list, element)
/* The very first thing we do is make sure none of these already exist in the list */
result = CList_findInList(*list, element, compare_fptr, NULL);
switch (result) {
case EPHIDGET_OK:
return EPHIDGET_DUPLICATE;
case EPHIDGET_NOTFOUND:
break;
default:
return result;
}
newentry = (CListHandle)malloc(sizeof(CList));
if (!newentry) return EPHIDGET_NOMEMORY;
ZEROMEM(newentry, sizeof(CList));
newentry->next = 0;
newentry->element = element;
if (!*list)
*list = newentry;
else
{
for (trav = *list; trav->next; trav = trav->next);
trav->next = newentry;
}
return EPHIDGET_OK;
}
int CCONV CPhidgetDictionary_getKey(CPhidgetDictionaryHandle dict, const char *key, char *val, int vallen)
{
int result, size;
char err[1024], *keywrap;
TESTPTRS(dict, key)
TESTPTR(val)
CThread_mutex_lock(&dict->lock);
if(!CPhidget_statusFlagIsSet(dict->status, PHIDGET_SERVER_CONNECTED_FLAG))
{
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_NETWORK_NOTCONNECTED;
}
//The get command returns a list of keys - since we want just a single key, lets wrap in ^ and $
//other reg exp tags are allowed and will be honoured
size = (int)strlen(key);
keywrap = (char *)malloc(size+3);
snprintf(keywrap, size+3, "^%s$",key);
CThread_mutex_lock(&dict->networkInfo->server->pdc_lock);
result = pdc_get(dict->networkInfo->server->pdcs, keywrap, val, vallen, err, sizeof(err));
CThread_mutex_unlock(&dict->networkInfo->server->pdc_lock);
free(keywrap);
CThread_mutex_unlock(&dict->lock);
if(result == 0) return EPHIDGET_UNEXPECTED;
return EPHIDGET_OK;
}
int CCONV CPhidgetDictionary_set_OnKeyChange_Handler(CPhidgetDictionaryHandle dict, CPhidgetDictionaryListenerHandle *dictlistener, const char *pattern,
int(CCONV *fptr)(CPhidgetDictionaryHandle dict, void *userPtr, const char *key, const char *val, CPhidgetDictionary_keyChangeReason reason),
void *userPtr)
{
CPhidgetDictionaryListenerHandle dict_listener;
char errdesc[1024];
int result;
TESTPTRS(dict, pattern)
TESTPTR(dictlistener)
CThread_mutex_lock(&dict->lock);
if(!CPhidget_statusFlagIsSet(dict->status, PHIDGET_SERVER_CONNECTED_FLAG))
{
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_NETWORK_NOTCONNECTED;
}
if(!(dict_listener = malloc(sizeof(CPhidgetDictionaryListener))))
{
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_NOMEMORY;
}
ZEROMEM(dict_listener, sizeof(CPhidgetDictionaryListener));
dict_listener->dict = dict;
dict_listener->fptr = fptr;
dict_listener->userPtr = userPtr;
CThread_mutex_lock(&dict->networkInfo->server->pdc_lock);
if (!(dict_listener->listen_id = pdc_listen(dict->networkInfo->server->pdcs, pattern, dict_event_handler, dict_listener, errdesc, sizeof (errdesc))))
{
LOG(PHIDGET_LOG_DEBUG,"pdc_listen: %s", errdesc);
free(dict_listener);
CThread_mutex_unlock(&dict->networkInfo->server->pdc_lock);
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_UNEXPECTED;
}
CThread_mutex_unlock(&dict->networkInfo->server->pdc_lock);
CThread_mutex_lock(&dict->listenersLock);
if((result = CList_addToList((CListHandle *)&dict->listeners, dict_listener, CPhidgetDictionaryListener_areEqual)))
{
CThread_mutex_unlock(&dict->listenersLock);
CThread_mutex_lock(&dict->networkInfo->server->pdc_lock);
pdc_ignore(dict->networkInfo->server->pdcs, dict_listener->listen_id, NULL, 0);
CThread_mutex_unlock(&dict->networkInfo->server->pdc_lock);
free(dict_listener);
CThread_mutex_unlock(&dict->lock);
return result;
}
CThread_mutex_unlock(&dict->listenersLock);
CThread_mutex_unlock(&dict->lock);
*dictlistener = dict_listener;
return EPHIDGET_OK;
}
/* Async add - errors returned to a registered error handler */
int CCONV CPhidgetDictionary_addKey(CPhidgetDictionaryHandle dict, const char *key, const char *val, int persistent)
{
TESTPTR(dict)
TESTPTRS(key, val)
CThread_mutex_lock(&dict->lock);
if(!CPhidget_statusFlagIsSet(dict->status, PHIDGET_SERVER_CONNECTED_FLAG))
{
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_NETWORK_NOTCONNECTED;
}
pdc_async_set(dict->networkInfo->server->pdcs, key, val, (int)strlen(val), persistent?0:1, internal_async_network_error_handler, dict);
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_OK;
}
int CCONV CPhidgetDictionary_removeKey(CPhidgetDictionaryHandle dict, const char *pattern)
{
int result;
char err[1024];
TESTPTRS(dict, pattern)
CThread_mutex_lock(&dict->lock);
if(!CPhidget_statusFlagIsSet(dict->status, PHIDGET_SERVER_CONNECTED_FLAG))
{
CThread_mutex_unlock(&dict->lock);
return EPHIDGET_NETWORK_NOTCONNECTED;
}
CThread_mutex_lock(&dict->networkInfo->server->pdc_lock);
result = pdc_remove(dict->networkInfo->server->pdcs, pattern, err, sizeof(err));
CThread_mutex_unlock(&dict->networkInfo->server->pdc_lock);
CThread_mutex_unlock(&dict->lock);
if(result == 0) return EPHIDGET_UNEXPECTED;
return EPHIDGET_OK;
}
int CCONV CPhidgetManager_getAttachedDevices(CPhidgetManagerHandle phidm, CPhidgetHandle *phidArray[], int *count)
{
CPhidgetList *trav = 0;
int i = 0;
TESTPTRS(phidArray, count)
TESTPTR(phidm)
*count = 0;
if(CPhidget_statusFlagIsSet(phidm->status, PHIDGET_REMOTE_FLAG))
{
for (trav=phidm->AttachedPhidgets; trav; trav = trav->next)
{
if (CPhidget_statusFlagIsSet(trav->phid->status, PHIDGET_ATTACHED_FLAG))
(*count)++;
}
if(*count==0)
{
*phidArray = NULL;
}
else
{
*phidArray = (CPhidgetHandle *)malloc(sizeof(**phidArray) * *count);
if (!*phidArray)
return EPHIDGET_NOMEMORY;
ZEROMEM(*phidArray, sizeof(**phidArray) * *count);
for (trav=phidm->AttachedPhidgets, i=0; trav; trav = trav->next)
{
if (CPhidget_statusFlagIsSet(trav->phid->status, PHIDGET_ATTACHED_FLAG))
{
(*phidArray)[i] = trav->phid;
i++;
}
}
}
}
else
{
CThread_mutex_lock(&attachedDevicesLock);
for (trav=AttachedDevices; trav; trav = trav->next)
{
if (CPhidget_statusFlagIsSet(trav->phid->status, PHIDGET_ATTACHED_FLAG))
(*count)++;
}
if(*count==0)
{
*phidArray = NULL;
}
else
{
*phidArray = (CPhidgetHandle *)malloc(sizeof(**phidArray) * *count);
if (!*phidArray)
{
CThread_mutex_unlock(&attachedDevicesLock);
return EPHIDGET_NOMEMORY;
}
ZEROMEM(*phidArray, sizeof(**phidArray) * *count);
for (trav=AttachedDevices, i=0; trav; trav = trav->next)
{
if (CPhidget_statusFlagIsSet(trav->phid->status, PHIDGET_ATTACHED_FLAG))
{
(*phidArray)[i] = trav->phid;
i++;
}
}
}
CThread_mutex_unlock(&attachedDevicesLock);
}
return EPHIDGET_OK;
}
