bool spoutSenderNames::GetSenderSet(std::set<std::string>& SenderNames) {
std::set<std::string>::iterator iter;
char* pBuf = NULL;
// Open or create m_sendernames
if (!CreateSenderSet()) {
return false;
}
pBuf = m_senderNames.Lock();
if (!pBuf) {
return false;
}
// The data has been stored with 256 bytes reserved for each Sender name
// and nothing will have changed with the map yet
if(pBuf[0] == 0) { // no senders yet
m_senderNames.Unlock();
return true;
}
// Read back from the mapped memory buffer and rebuild the set that was passed in
// The set will then contain the senders currently in the memory map
// and allow for any that have been added or deleted
readSenderSetFromBuffer(pBuf, SenderNames, m_MaxSenders);
m_senderNames.Unlock();
return true;
} // end GetSenderSet
// TODO - use pointer from initial map creation
bool spoutSenderNames::GetSenderSet(std::set<string>& SenderNames) {
string namestring; // local string to retrieve names
std::set<string>::iterator iter;
if (!CreateSenderSet())
{
return false;
}
char* pBuf = m_senderNames.Lock();
if (!pBuf)
{
return false;
}
// The data has been stored with 256 bytes reserved for each Sender name
// and nothing will have changed with the map yet
// MB - Use alloca, we know the data is small enough to fit on the stack
char *buffer = (char *)_alloca(MaxSenders*SpoutMaxSenderNameLen*sizeof(unsigned char));
// copy the shared memory to the local buffer
memcpy ( (void *)buffer, (void *)pBuf, MaxSenders*SpoutMaxSenderNameLen );
m_senderNames.Unlock();
// Read back from the buffer and rebuild the set
readSenderSetFromBuffer(buffer, SenderNames);
return true;
} // end GetSenderSet
//
// Removes a Sender from the set of Sender names
//
bool spoutSenderNames::ReleaseSenderName(const char* Sendername)
{
std::set<std::string> SenderNames;
std::string namestring;
char name[SpoutMaxSenderNameLen];
// Create the shared memory for the sender name set if it does not exist
if(!CreateSenderSet()) return false;
char *pBuf = m_senderNames.Lock();
if (!pBuf) return false;
namestring = Sendername;
auto foundSender = m_senders->find(namestring);
if (foundSender != m_senders->end()) {
delete foundSender->second;
m_senders->erase(namestring);
}
readSenderSetFromBuffer(pBuf, SenderNames, m_MaxSenders);
// Discovered that the project properties had been set to CLI
// Properties -> General -> Common Language Runtime Support
// and this caused the set "find" function not to work.
// It also disabled intellisense.
// Get the current map to update the list
if(SenderNames.find(Sendername) != SenderNames.end() ) {
SenderNames.erase(Sendername); // erase the matching Sender
writeBufferFromSenderSet(SenderNames, pBuf, m_MaxSenders);
// Is there a set left ?
if(SenderNames.size() > 0) {
// This should be OK because the user selects the active sender
// Was it the active sender ?
if( (getActiveSenderName(name) && strcmp(name, Sendername) == 0) || SenderNames.size() == 1) {
// It was, so choose the first in the list
std::set<std::string>::iterator iter = SenderNames.begin();
namestring = *iter;
strcpy_s(name, namestring.c_str());
// Set it as the active sender
setActiveSenderName(name);
}
}
m_senderNames.Unlock();
return true;
}
m_senderNames.Unlock();
return false; // Sender name not in the set or no set in shared mempry
} // end RemoveSender
//
// =========================
// multiple Sender functions
// =========================
//
// Register a new Sender by adding to the list of Sender names
//
bool spoutSenderNames::RegisterSenderName(const char* Sendername) {
std::pair<std::set<std::string>::iterator, bool> ret;
std::set<std::string> SenderNames; // set of names
// Create the shared memory for the sender name set if it does not exist
if(!CreateSenderSet()) return false;
char *pBuf = m_senderNames.Lock();
if (!pBuf) return false;
// Register the sender name in the list of spout senders
readSenderSetFromBuffer(pBuf, SenderNames, m_MaxSenders);
//
// Add the Sender name to the set of names
//
ret = SenderNames.insert(Sendername);
if(!ret.second) {
// See if there are any dangling entries that aren't valid anymore
cleanSenderSet();
readSenderSetFromBuffer(pBuf, SenderNames, m_MaxSenders);
ret = SenderNames.insert(Sendername);
}
if(ret.second) {
// write the new map to shared memory
writeBufferFromSenderSet(SenderNames, pBuf, m_MaxSenders);
// Set as the active Sender if it is the first one registered
// Thereafter the user can select an active Sender using SpoutPanel or SpoutSenders
m_activeSender.Create("ActiveSenderName", SpoutMaxSenderNameLen);
// The active sender is the one selected by the user
// or the last one opened by the user, so don't limit to the first sender
// Set the current sender name as active
SetActiveSender(Sendername);
}
m_senderNames.Unlock();
return ret.second;
}
void spoutSenderNames::cleanSenderSet()
{
if(!CreateSenderSet()) {
return;
}
char *pBuf = m_senderNames.Lock();
if (!pBuf) {
return;
}
std::set<std::string> SenderNames;
readSenderSetFromBuffer(pBuf, SenderNames, m_MaxSenders);
bool changed = false;
for (auto itr = SenderNames.begin(); itr != SenderNames.end(); )
{
// It's one of ours, so thats fine
if (m_senders->find(*itr) != m_senders->end())
{
itr++;
continue;
}
SpoutSharedMemory mem;
// This isn't found, we clean it up
if (!mem.Open((*itr).c_str()))
{
changed = true;
SenderNames.erase(itr++);
}
else
{
++itr;
}
}
if (changed)
{
writeBufferFromSenderSet(SenderNames, pBuf, m_MaxSenders);
}
m_senderNames.Unlock();
}
