void LocalAddressReceiver::removeReceiveAddress( char *inAddress ) {
mReceiveAddressLock->lock();
int index = findAddressIndex( inAddress );
if( index != -1 ) {
delete [] *( mAddressVector->getElement( index ) );
mAddressVector->deleteElement( index );
SimpleVector<char *> *currentMessageQueue
= *( mMessageQueueVector->getElement( index ) );
SimpleVector<char *> *currentFromAddressQueue
= *( mFromAddressQueueVector->getElement( index ) );
int numInQueue = currentMessageQueue->size();
for( int j=0; j<numInQueue; j++ ) {
delete [] *( currentMessageQueue->getElement( j ) );
delete [] *( currentFromAddressQueue->getElement( j ) );
}
delete currentMessageQueue;
delete currentFromAddressQueue;
mMessageQueueVector->deleteElement( index );
mFromAddressQueueVector->deleteElement( index );
}
mReceiveAddressLock->unlock();
}
void
unsetAddressName (void *address) {
int index;
if (findAddressIndex(&index, address)) {
removeAddressEntry(index);
}
}
unsigned int LocalAddressReceiver::getReceivedMessages(
char *inAddress,
unsigned int inNumMessages,
char ***outMessages,
char ***outFromAddresses ) {
mReceiveAddressLock->lock();
int index = findAddressIndex( inAddress );
int returnValue;
char **messages;
char **fromAddresses;
if( index != -1 ) {
SimpleVector<char *> *currentMessageQueue
= *( mMessageQueueVector->getElement( index ) );
SimpleVector<char *> *currentFromAddressQueue
= *( mFromAddressQueueVector->getElement( index) );
int numToGet = inNumMessages;
int numAvailable = currentMessageQueue->size();
if( numToGet > numAvailable ) {
numToGet = numAvailable;
}
messages = new char*[numToGet];
fromAddresses = new char*[numToGet];
for( int i=0; i<numToGet; i++ ) {
messages[i] = *( currentMessageQueue->getElement(0) );
fromAddresses[i] = *( currentFromAddressQueue->getElement(0) );
currentMessageQueue->deleteElement( 0 );
currentFromAddressQueue->deleteElement( 0 );
}
returnValue = numToGet;
}
else {
returnValue = 0;
messages = new char*[0];
fromAddresses = new char*[0];
}
*outMessages = messages;
*outFromAddresses = fromAddresses;
mReceiveAddressLock->unlock();
return returnValue;
}
const char *
getAddressName (void *address, ptrdiff_t *offset) {
{
int index;
if (findAddressIndex(&index, address)) {
if (offset) *offset = 0;
return addressTable[index]->name;
}
}
return getSharedSymbolName(address, offset);
}
void LocalAddressReceiver::addReceiveAddress( char *inAddress ) {
mReceiveAddressLock->lock();
// make sure address not already added
int index = findAddressIndex( inAddress );
if( index != -1 ) {
mReceiveAddressLock->unlock();
return;
}
// add address and a message queue
mAddressVector->push_back( stringDuplicate( inAddress ) );
mMessageQueueVector->push_back( new SimpleVector<char *>() );
mFromAddressQueueVector->push_back( new SimpleVector<char *>() );
mReceiveAddressLock->unlock();
}
unsigned int LocalAddressReceiver::getWaitingMessageCount( char *inAddress ) {
mReceiveAddressLock->lock();
int index = findAddressIndex( inAddress );
unsigned int returnValue;
if( index != -1 ) {
SimpleVector<char *> *currentMessageQueue
= *( mMessageQueueVector->getElement( index ) );
returnValue = currentMessageQueue->size();
}
else {
returnValue = 0;
}
mReceiveAddressLock->unlock();
return returnValue;
}
int
setAddressName (void *address, const char *format, ...) {
char name[0X1000];
AddressEntry *entry;
size_t size;
{
va_list arguments;
va_start(arguments, format);
vsnprintf(name, sizeof(name), format, arguments);
va_end(arguments);
}
size = sizeof(*entry) + strlen(name) + 1;
if ((entry = malloc(size))) {
int index;
memset(entry, 0, sizeof(*entry));
entry->address = address;
strcpy(entry->name, name);
if (findAddressIndex(&index, address)) {
free(addressTable[index]);
addressTable[index] = entry;
return 1;
}
if (insertAddressEntry(index, entry)) return 1;
free(entry);
} else {
logMallocError();
}
return 0;
}
char LocalAddressReceiver::messageReceived( char *inFromAddress,
char *inToAddress,
char *inBody,
int *outUtilityGenerated ) {
mReceiveAddressLock->lock();
// track the utility that our handlers generate for this message
int utility = 0;
{
int numHandlers = mGlobalMessageHandlerVector->size();
for( int i=0; i<numHandlers; i++ ) {
MessageHandlerWrapper *wrapper =
*( mGlobalMessageHandlerVector->getElement( i ) );
utility +=
wrapper->mHandlerFunction(
inFromAddress, inToAddress, inBody,
wrapper->mExtraHandlerArgument );
}
}
int index = findAddressIndex( inToAddress );
if( index != -1 ) {
// received locally
if (!mHandlerLock->tryLockForRead(2000))
{
//FIXME : if no lock obtained after 2 seconds : what to do ?
printf("strange, lock for read in messageREceived not obtained!!!\n");
}
int numHandlers = mMessageHandlerVector->size();
if( numHandlers <= 0 ) {
mHandlerLock->unlock();
// no handlers, so queue messages
SimpleVector<char *> *currentMessageQueue
= *( mMessageQueueVector->getElement( index ) );
SimpleVector<char *> *currentFromAddressQueue
= *( mFromAddressQueueVector->getElement( index) );
currentMessageQueue->push_back( stringDuplicate( inBody ) );
currentFromAddressQueue->push_back(
stringDuplicate( inFromAddress ) );
mReceiveAddressLock->unlock();
}
else {
// pass message to each handler
// unlock so that handlers can modify receive addresses
mReceiveAddressLock->unlock();
for( int i=0; i<numHandlers; i++ ) {
MessageHandlerWrapper *wrapper =
*( mMessageHandlerVector->getElement( i ) );
utility +=
wrapper->mHandlerFunction(
inFromAddress, inToAddress, inBody,
wrapper->mExtraHandlerArgument );
}
mHandlerLock->unlock();
}
// message was received locally
*outUtilityGenerated = utility;
return true;
}
else {
mReceiveAddressLock->unlock();
*outUtilityGenerated = utility;
// utility >= 1000 when chunk returned from cache
if (utility >= 1000)
return true;
return false;
}
}
