void ScriptSystem::getClassList(const char* prefix, bool sort, StringSeq& result) const {
ClassInfoDict::const_iterator it = m_classInfoReg.begin();
size_t prefixlen = 0;
if (prefix) {
prefixlen = strlen(prefix);
}
for (; it != m_classInfoReg.end(); ++it) {
ClassInfo* ci = it->second;
if (prefixlen) {
if (strncmp(prefix, ci->m_className.c_str(), prefixlen) != 0) {
continue;
}
result.push_back(ci->m_className.c_str() + prefixlen);
} else {
result.push_back(ci->m_className);
}
}
if (sort) {
std::sort(result.begin(), result.end(), std::less<String>());
}
}
void
Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
{
//
// Shift all elements in argv which are present in args to the
// beginning of argv.
//
int i = 0;
while(i < argc)
{
if(find(args.begin(), args.end(), argv[i]) == args.end())
{
for(int j = i; j < argc - 1; j++)
{
argv[j] = argv[j + 1];
}
--argc;
}
else
{
++i;
}
}
//
// Make sure that argv[argc] == 0, the ISO C++ standard requires this.
//
if(argv)
{
argv[argc] = 0;
}
}
IceInternal::ProxyFactory::ProxyFactory(const InstancePtr& instance) :
_instance(instance)
{
StringSeq retryValues = _instance->initializationData().properties->getPropertyAsList("Ice.RetryIntervals");
if(retryValues.size() == 0)
{
_retryIntervals.push_back(0);
}
else
{
for(StringSeq::const_iterator p = retryValues.begin(); p != retryValues.end(); ++p)
{
istringstream value(*p);
int v;
if(!(value >> v) || !value.eof())
{
v = 0;
}
//
// If -1 is the first value, no retry and wait intervals.
//
if(v == -1 && _retryIntervals.empty())
{
break;
}
_retryIntervals.push_back(v > 0 ? v : 0);
}
}
}
int main(int argc, char* argv[])
{
CoInitializeEx(NULL, 0);
Ice::InitializationData id = InitializationData();
id.properties = Ice::createProperties();
id.properties->load("config.server");
id.logger = new MyLoggerI();
Ice::initialize(argc, argv, id);
SyncService svc;
int status = EXIT_FAILURE;
#ifdef _WIN32
status = svc.main(argc, argv, id);
#else
//
// For UNIX, force --nochdir option, so the service isn't started
// with / as the working directory. That way, if the data
// directory is specified as a relative path, we don't
// misinterpret that path.
//
StringSeq args;
args.push_back(argv[0]);
args.push_back("--nochdir");
for(int i = 1; i < argc; ++i)
{
args.push_back(argv[i]);
}
status = svc.main(args);
#endif
return status;
}
void golem::findSensor(const Sensor::Map& sensors, const StringSeq& idSeq, Sensor::Seq& sensorSeq) {
for (StringSeq::const_iterator i = idSeq.begin(); i != idSeq.end(); ++i) {
golem::Sensor::Map::const_iterator pSensor = std::find_if(sensors.begin(), sensors.end(), [=](const golem::Sensor::Map::value_type& val) -> bool { return val.first == *i; });
if (pSensor == sensors.end())
throw Message(Message::LEVEL_CRIT, "findSensor(): unknown sensor id: %s", i->c_str());
sensorSeq.push_back(pSensor->second.get());
}
}
StringSeq golem::data::HandlerTrajectory::getProfiles() const {
StringSeq profiles;
for (auto& k : profileDescMap)
profiles.push_back(k.first);
return profiles;
}
void
IceInternal::ReferenceFactory::checkForUnknownProperties(const string& prefix)
{
static const string suffixes[] =
{
"EndpointSelection",
"ConnectionCached",
"PreferSecure",
"LocatorCacheTimeout",
"InvocationTimeout",
"Locator",
"Router",
"CollocationOptimized",
"Context.*"
};
//
// Do not warn about unknown properties list if Ice prefix, ie Ice, Glacier2, etc
//
for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i)
{
if(prefix.find(*i) == 0)
{
return;
}
}
StringSeq unknownProps;
PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix + ".");
for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
{
bool valid = false;
for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i)
{
string prop = prefix + "." + suffixes[i];
if(IceUtilInternal::match(p->first, prop))
{
valid = true;
break;
}
}
if(!valid)
{
unknownProps.push_back(p->first);
}
}
if(unknownProps.size())
{
Warning out(_instance->initializationData().logger);
out << "found unknown properties for proxy '" << prefix << "':";
for(unsigned int i = 0; i < unknownProps.size(); ++i)
{
out << "\n " << unknownProps[i];
}
}
}
StringSeq
Ice::argsToStringSeq(int argc, char* argv[])
{
StringSeq result;
for(int i = 0; i < argc; i++)
{
result.push_back(argv[i]);
}
return result;
}
StringSeq PathUtil::listFileByExts(const String& base, const String& path, const String& exts, uint_t flags) {
StringSeq strvec;
FileInfoSeq fileinfos;
fileinfos = getFileInfos(base, path, exts, flags);
for (size_t i=0; i<fileinfos.size(); i++) {
strvec.push_back(fileinfos[i].fullpath);
}
return strvec;
}
StringSeq
Ice::PluginManagerI::getPlugins()
{
IceUtil::Mutex::Lock sync(*this);
StringSeq names;
for(PluginInfoList::iterator p = _plugins.begin(); p != _plugins.end(); ++p)
{
names.push_back(p->name);
}
return names;
}
CommunicatorPtr
Ice::initialize(StringSeq& args, const InitializationData& initializationData, Int version)
{
int origArgc = 0;
char** argv = 0;
CommunicatorPtr communicator;
try
{
//
// Make a dummy argc/argv.
// (We can't use argsToStringSeq() because that requires an already initialized argv.)
//
int argc = static_cast<int>(args.size());
origArgc = argc;
argv = new char*[args.size() + 1];
int i;
for(i = 0; i != argc; ++i)
{
argv[i] = new char[args[i].size() + 1];
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
strcpy_s(argv[i], args[i].size() + 1, args[i].c_str());
#else
strcpy(argv[i], args[i].c_str());
#endif
}
argv[argc] = 0;
communicator = initialize(argc, argv, initializationData, version);
args = argsToStringSeq(argc, argv);
for(i = 0; i < origArgc; ++i)
{
delete[] argv[i];
}
delete[] argv;
}
catch(...)
{
for(int i = 0; i < origArgc; ++i)
{
delete[] argv[i];
}
delete[] argv;
throw;
}
return communicator;
}
StringSeq
Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
{
//
// Don't need to use a wide string converter argv is expected to
// come from Windows API.
//
const IceUtil::StringConverterPtr converter = IceUtil::getProcessStringConverter();
StringSeq args;
for(int i=0; argv[i] != 0; i++)
{
args.push_back(IceUtil::wstringToString(argv[i], converter));
}
return args;
}
bool
Ice::ObjectAdapterI::filterProperties(StringSeq& unknownProps)
{
static const string suffixes[] =
{
"AdapterId",
"Endpoints",
"Locator",
"PublishedEndpoints",
"RegisterProcess",
"ReplicaGroupId",
"Router",
"ThreadPerConnection",
"ThreadPerConnection.StackSize",
"ThreadPool.Size",
"ThreadPool.SizeMax",
"ThreadPool.SizeWarn",
"ThreadPool.StackSize"
};
//
// Do not create unknown properties list if Ice prefix, ie Ice, Glacier2, etc
//
bool addUnknown = true;
string prefix = _name + ".";
for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i)
{
string icePrefix = string(*i) + ".";
if(prefix.find(icePrefix) == 0)
{
addUnknown = false;
break;
}
}
bool noProps = true;
PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix);
PropertyDict::const_iterator p;
for(p = props.begin(); p != props.end(); ++p)
{
bool valid = false;
for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i)
{
string prop = prefix + suffixes[i];
if(p->first == prop)
{
noProps = false;
valid = true;
break;
}
}
if(!valid && addUnknown)
{
unknownProps.push_back(p->first);
}
}
return noProps;
}
StringSeq StringUtil::tokenizeSeq(const char* text, char split /*= ' ' */) {
StringSeq result;
if (!text || !text[0])
return result;
String str;
const char* token = text;
for (; ;) {
/* skip whitespace */
while (*token && uint_t(*token) <= ' ' || *token == split) {
token++;
}
if (!*token) break;
str.clear();
// handle quoted strings
if (*token == '\"') {
token++;
while (*token && *token != '\"') {
str += *token++;
}
result.push_back(str);
str.clear();
if (!*token) {
break;
} else {
token++;
continue;
}
}
do {
str+=*token; token++;
} while (*token != 0 && *token != split);
result.push_back(str);
}
return result;
}
void
Ice::stringSeqToArgs(const StringSeq& args, int& argc, const wchar_t* argv[])
{
//
// Don't need to use a wide string converter argv is expected to
// come from Windows API.
//
const StringConverterPtr converter = getProcessStringConverter();
//
// Shift all elements in argv which are present in args to the
// beginning of argv. We record the original value of argc so
// that we can know later if we've shifted the array.
//
const int argcOrig = argc;
int i = 0;
while(i < argc)
{
if(find(args.begin(), args.end(), wstringToString(argv[i], converter)) == args.end())
{
for(int j = i; j < argc - 1; j++)
{
argv[j] = argv[j + 1];
}
--argc;
}
else
{
++i;
}
}
//
// Make sure that argv[argc] == 0, the ISO C++ standard requires this.
// We can only do this if we've shifted the array, otherwise argv[argc]
// may point to an invalid address.
//
if(argv && argcOrig != argc)
{
argv[argc] = 0;
}
}
IceBox::ServiceManagerI::ServiceManagerI(CommunicatorPtr communicator, int& argc, char* argv[]) :
_communicator(communicator),
_adminEnabled(false),
_pendingStatusChanges(false),
_traceServiceObserver(0)
{
#ifndef ICE_CPP11_MAPPING
const_cast<CallbackPtr&>(_observerCompletedCB) = newCallback(this, &ServiceManagerI::observerCompleted);
#endif
_logger = _communicator->getLogger();
PropertiesPtr props = _communicator->getProperties();
_traceServiceObserver = props->getPropertyAsInt("IceBox.Trace.ServiceObserver");
if(props->getProperty("Ice.Admin.Enabled") == "")
{
_adminEnabled = props->getProperty("Ice.Admin.Endpoints") != "";
}
else
{
_adminEnabled = props->getPropertyAsInt("Ice.Admin.Enabled") > 0;
}
if(_adminEnabled)
{
StringSeq facetSeq = props->getPropertyAsList("Ice.Admin.Facets");
if(!facetSeq.empty())
{
_adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
}
}
for(int i = 1; i < argc; i++)
{
_argv.push_back(argv[i]);
}
}
void
Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
{
//
// Shift all elements in argv which are present in args to the
// beginning of argv. We record the original value of argc so
// that we can know later if we've shifted the array.
//
const int argcOrig = argc;
int i = 0;
while(i < argc)
{
if(find(args.begin(), args.end(), argv[i]) == args.end())
{
for(int j = i; j < argc - 1; j++)
{
argv[j] = argv[j + 1];
}
--argc;
}
else
{
++i;
}
}
//
// Make sure that argv[argc] == 0, the ISO C++ standard requires this.
// We can only do this if we've shifted the array, otherwise argv[argc]
// may point to an invalid address.
//
if(argv && argcOrig != argc)
{
argv[argc] = 0;
}
}
//string domainid,deviceid,loginfo,logdata,logconfpath;
int alarmSubscribeBloodPressure(string domainid,string deviceid,int sysmin,int sysmax,int dismin,int dismax,int pulsemin,int pulsemax,string loginfo,string logdata,string logconfpath)
{
sysmin = 90;
sysmax = 140;
dismin = 60;
dismax = 90;
pulsemin = 60;
pulsemax = 90;
/*Initializing SimpleDDS library*/
DataService *simpledds;
BloodPressureTypeSupport_var typesupport;
DataReader_ptr content_reader;
BloodPressureDataReader_var bpReader;
ReturnCode_t status;
int i=0;
/*Setting QoS Properties for Topic*/
DDS::TopicQos tQos;
getQos(tQos);
simpledds = new OpenSpliceDataService(tQos,loginfo,logconfpath);
typesupport = new BloodPressureTypeSupport();
simpledds->logger->info(" Blood Pressure Alarm Subscriber Started %s" ,deviceid.c_str());
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
bpReader = BloodPressureDataReader::_narrow(content_reader);
BloodPressureSeq bpList;
SampleInfoSeq infoSeq;
simpledds->logger->info("Blood Pressure alarm Subscriber for %s",deviceid.c_str());
simpledds->logger->info("Format: DOMAIN_ID, DEVICE_ID, MEASURED_TIME, SYSTOLIC(LEVEL), DIASTOLIC(LEVEL), PULSERATE(LEVEL)");
while (1)
{
status = bpReader->take(
bpList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < bpList.length(); i++)
{
if(infoSeq[i].valid_data)
{
if (bpList[i].systolicPressure < sysmin || bpList[i].systolicPressure > sysmax || bpList[i].diastolicPressure < dismin || bpList[i].diastolicPressure > dismax || bpList[i].pulseRatePerMinute < pulsemin || bpList[i].pulseRatePerMinute > pulsemax)
{
prtemp <<bpList[i].deviceDomain<<COMMA<<bpList[i].deviceID<<COMMA;
prtemp <<bpList[i].timeOfMeasurement<<COMMA<<alarmString(bpList[i].systolicPressure,sysmin,sysmax);
prtemp <<COMMA<<alarmString(bpList[i].diastolicPressure,dismin,dismax)<<COMMA;
prtemp <<alarmString(bpList[i].pulseRatePerMinute,pulsemin,pulsemax);
simpledds->logger->info(prtemp.str().c_str());
prtemp.str(CLEAN);
}
}
}
status = bpReader->return_loan(bpList, infoSeq);
checkStatus(status, "return_loan");
}
simpledds->logger->info("Blood Pressure alarm Subscriber Ends");
/* We're done. Delete everything */
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}
int
main (
int ,
char *[])
{
/* Generic DDS entities */
DomainParticipant_var participant;
Topic_var chatMessageTopic;
Topic_var nameServiceTopic;
Subscriber_var chatSubscriber;
DataReader_ptr parentReader;
QueryCondition_var singleUser;
ReadCondition_var newUser;
StatusCondition_var leftUser;
WaitSet_var userLoadWS;
LivelinessChangedStatus livChangStatus;
/* QosPolicy holders */
TopicQos setting_topic_qos;
TopicQos reliable_topic_qos;
SubscriberQos sub_qos;
DataReaderQos message_qos;
/* DDS Identifiers */
DomainId_t domain = NULL;
ReturnCode_t status;
ConditionSeq guardList;
/* Type-specific DDS entities */
ChatMessageTypeSupport_var chatMessageTS;
NameServiceTypeSupport_var nameServiceTS;
NameServiceDataReader_var nameServer;
ChatMessageDataReader_var loadAdmin;
ChatMessageSeq msgList;
NameServiceSeq nsList;
SampleInfoSeq infoSeq;
SampleInfoSeq infoSeq2;
/* Others */
StringSeq args;
char * chatMessageTypeName = NULL;
char * nameServiceTypeName = NULL;
bool closed = false;
CORBA::Long prevCount = 0;
DWORD tid;
HANDLE tHandle = INVALID_HANDLE_VALUE;
/* Create a DomainParticipant (using the 'TheParticipantFactory' convenience macro). */
participant = TheParticipantFactory->create_participant (
domain,
PARTICIPANT_QOS_DEFAULT,
NULL,
STATUS_MASK_NONE);
checkHandle(participant.in(), "DDS::DomainParticipantFactory::create_participant");
/* Register the required datatype for ChatMessage. */
chatMessageTS = new ChatMessageTypeSupport();
checkHandle(chatMessageTS.in(), "new ChatMessageTypeSupport");
chatMessageTypeName = chatMessageTS->get_type_name();
status = chatMessageTS->register_type(participant.in(), chatMessageTypeName);
checkStatus(status, "Chat::ChatMessageTypeSupport::register_type");
/* Register the required datatype for NameService. */
nameServiceTS = new NameServiceTypeSupport();
checkHandle(nameServiceTS.in(), "new NameServiceTypeSupport");
nameServiceTypeName = nameServiceTS->get_type_name();
status = nameServiceTS->register_type(participant.in(), nameServiceTypeName);
checkStatus(status, "Chat::NameServiceTypeSupport::register_type");
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant->get_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos");
reliable_topic_qos.reliability.kind = RELIABLE_RELIABILITY_QOS;
/* Make the tailored QoS the new default. */
status = participant->set_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::set_default_topic_qos");
/* Use the changed policy when defining the ChatMessage topic */
chatMessageTopic = participant->create_topic(
"Chat_ChatMessage",
chatMessageTypeName,
reliable_topic_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::create_topic (ChatMessage)");
/* Set the DurabilityQosPolicy to TRANSIENT. */
status = participant->get_default_topic_qos(setting_topic_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos");
setting_topic_qos.durability.kind = TRANSIENT_DURABILITY_QOS;
/* Create the NameService Topic. */
nameServiceTopic = participant->create_topic(
"Chat_NameService",
nameServiceTypeName,
setting_topic_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(nameServiceTopic.in(), "DDS::DomainParticipant::create_topic");
/* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */
status = participant->get_default_subscriber_qos (sub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_subscriber_qos");
sub_qos.partition.name.length(1);
sub_qos.partition.name[0UL] = "ChatRoom";
/* Create a Subscriber for the UserLoad application. */
chatSubscriber = participant->create_subscriber(sub_qos, NULL, STATUS_MASK_NONE);
checkHandle(chatSubscriber.in(), "DDS::DomainParticipant::create_subscriber");
/* Create a DataReader for the NameService Topic (using the appropriate QoS). */
parentReader = chatSubscriber->create_datareader(
nameServiceTopic.in(),
DATAREADER_QOS_USE_TOPIC_QOS,
NULL,
STATUS_MASK_NONE);
checkHandle(parentReader, "DDS::Subscriber::create_datareader (NameService)");
/* Narrow the abstract parent into its typed representative. */
nameServer = NameServiceDataReader::_narrow(parentReader);
checkHandle(nameServer.in(), "Chat::NameServiceDataReader::_narrow");
/* Adapt the DataReaderQos for the ChatMessageDataReader to keep track of all messages. */
status = chatSubscriber->get_default_datareader_qos(message_qos);
checkStatus(status, "DDS::Subscriber::get_default_datareader_qos");
status = chatSubscriber->copy_from_topic_qos(message_qos, reliable_topic_qos);
checkStatus(status, "DDS::Subscriber::copy_from_topic_qos");
message_qos.history.kind = KEEP_ALL_HISTORY_QOS;
/* Create a DataReader for the ChatMessage Topic (using the appropriate QoS). */
parentReader = chatSubscriber->create_datareader(
chatMessageTopic.in(),
message_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(parentReader, "DDS::Subscriber::create_datareader (ChatMessage)");
/* Narrow the abstract parent into its typed representative. */
loadAdmin = ChatMessageDataReader::_narrow(parentReader);
checkHandle(loadAdmin.in(), "Chat::ChatMessageDataReader::_narrow");
/* Initialize the Query Arguments. */
args.length(1);
args[0UL] = "0";
/* Create a QueryCondition that will contain all messages with userID=ownID */
singleUser = loadAdmin->create_querycondition(
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE,
"userID=%0",
args);
checkHandle(singleUser.in(), "DDS::DataReader::create_querycondition");
/* Create a ReadCondition that will contain new users only */
newUser = nameServer->create_readcondition(
NOT_READ_SAMPLE_STATE,
NEW_VIEW_STATE,
ALIVE_INSTANCE_STATE);
checkHandle(newUser.in(), "DDS::DataReader::create_readcondition");
/* Obtain a StatusCondition that triggers only when a Writer changes Liveliness */
leftUser = loadAdmin->get_statuscondition();
checkHandle(leftUser.in(), "DDS::DataReader::get_statuscondition");
status = leftUser->set_enabled_statuses(LIVELINESS_CHANGED_STATUS);
checkStatus(status, "DDS::StatusCondition::set_enabled_statuses");
/* Create a bare guard which will be used to close the room */
escape = new GuardCondition();
/* Create a waitset and add the ReadConditions */
userLoadWS = new WaitSet();
status = userLoadWS->attach_condition(newUser.in());
checkStatus(status, "DDS::WaitSet::attach_condition (newUser)");
status = userLoadWS->attach_condition(leftUser.in());
checkStatus(status, "DDS::WaitSet::attach_condition (leftUser)");
status = userLoadWS->attach_condition(escape.in());
checkStatus(status, "DDS::WaitSet::attach_condition (escape)");
/* Initialize and pre-allocate the GuardList used to obtain the triggered Conditions. */
guardList.length(3);
/* Remove all known Users that are not currently active. */
status = nameServer->take(
nsList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
NOT_ALIVE_INSTANCE_STATE);
checkStatus(status, "Chat::NameServiceDataReader::take");
status = nameServer->return_loan(nsList, infoSeq);
checkStatus(status, "Chat::NameServiceDataReader::return_loan");
/* Start the sleeper thread. */
tHandle = CreateThread(NULL, 0, delayedEscape, NULL, 0, &tid);
while (!closed) {
/* Wait until at least one of the Conditions in the waitset triggers. */
status = userLoadWS->wait(guardList, DURATION_INFINITE);
checkStatus(status, "DDS::WaitSet::wait");
/* Walk over all guards to display information */
for (CORBA::ULong i = 0; i < guardList.length(); i++) {
if ( guardList[i].in() == newUser.in() ) {
/* The newUser ReadCondition contains data */
status = nameServer->read_w_condition(
nsList,
infoSeq,
LENGTH_UNLIMITED,
newUser.in() );
checkStatus(status, "Chat::NameServiceDataReader::read_w_condition");
for (CORBA::ULong j = 0; j < nsList.length(); j++) {
cout << "New user: "******"Chat::NameServiceDataReader::return_loan");
} else if ( guardList[i].in() == leftUser.in() ) {
/* Some liveliness has changed (either a DataWriter joined or a DataWriter left) */
status = loadAdmin->get_liveliness_changed_status(livChangStatus);
checkStatus(status, "DDS::DataReader::get_liveliness_changed_status");
if (livChangStatus.alive_count < prevCount) {
/* A user has left the ChatRoom, since a DataWriter lost its liveliness */
/* Take the effected users so tey will not appear in the list later on. */
status = nameServer->take(
nsList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
checkStatus(status, "Chat::NameServiceDataReader::take");
for (CORBA::ULong j = 0; j < nsList.length(); j++) {
/* re-apply query arguments */
ostringstream numberString;
numberString << nsList[j].userID;
args[0UL] = numberString.str().c_str();
status = singleUser->set_query_parameters(args);
checkStatus(status, "DDS::QueryCondition::set_query_parameters");
/* Read this users history */
status = loadAdmin->take_w_condition(
msgList,
infoSeq2,
LENGTH_UNLIMITED,
singleUser.in() );
checkStatus(status, "Chat::ChatMessageDataReader::take_w_condition");
/* Display the user and his history */
cout << "Departed user " << nsList[j].name << " has sent " <<
msgList.length() << " messages." << endl;
status = loadAdmin->return_loan(msgList, infoSeq2);
checkStatus(status, "Chat::ChatMessageDataReader::return_loan");
}
status = nameServer->return_loan(nsList, infoSeq);
checkStatus(status, "Chat::NameServiceDataReader::return_loan");
}
prevCount = livChangStatus.alive_count;
} else if ( guardList[i].in() == escape.in() ) {
cout << "UserLoad has terminated." << endl;
closed = true;
}
else
{
assert(0);
};
} /* for */
} /* while (!closed) */
/* Remove all Conditions from the WaitSet. */
status = userLoadWS->detach_condition( escape.in() );
checkStatus(status, "DDS::WaitSet::detach_condition (escape)");
status = userLoadWS->detach_condition( leftUser.in() );
checkStatus(status, "DDS::WaitSet::detach_condition (leftUser)");
status = userLoadWS->detach_condition( newUser.in() );
checkStatus(status, "DDS::WaitSet::detach_condition (newUser)");
/* Remove the type-names. */
CORBA::string_free(chatMessageTypeName);
CORBA::string_free(nameServiceTypeName);
/* Free all resources */
status = participant->delete_contained_entities();
checkStatus(status, "DDS::DomainParticipant::delete_contained_entities");
status = TheParticipantFactory->delete_participant( participant.in() );
checkStatus(status, "DDS::DomainParticipantFactory::delete_participant");
CloseHandle(tHandle);
return 0;
}
int main(int argc, char* argv[])
{
if (!parse_args_sub(argc, argv,domainid,deviceid,loginfo,logdata,logconfpath))
return 1;
/*Importing log4cpp configuration and Creating category*/
log4cpp::Category &log_root = log4cpp::Category::getRoot();
log4cpp::Category &bloodInfo = log4cpp::Category::getInstance( std::string(loginfo));
log4cpp::Category &bloodEcho = log4cpp::Category::getInstance( std::string(logdata));
log4cpp::PropertyConfigurator::configure(logconfpath);
bloodInfo.notice(" Blood Pressure Subscriber Started " +deviceid);
/*Initializing SimpleDDS library*/
SimpleDDS *simpledds;
BloodPressureTypeSupport_var typesupport;
DataReader_ptr content_reader;
BloodPressureDataReader_var bpReader;
ReturnCode_t status;
int i=0;
/*Setting QoS Properties for Topic*/
DDS::TopicQos tQos;
getQos(tQos);
tQos.durability_service.history_depth= 1024;
/*Initializing Subscriber and DataWriter*/
simpledds = new SimpleDDS(tQos);
typesupport = new BloodPressureTypeSupport();
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
bpReader = BloodPressureDataReader::_narrow(content_reader);
BloodPressureSeq bpList;
SampleInfoSeq infoSeq;
bloodInfo.notice("Blood Pressure Subscriber For "+deviceid);
bloodInfo.notice("Format: DOMAIN_ID, DEVICE_ID, MEASURED_TIME, SYSTOLIC, DIASTOLIC, PULSERATE");
/*Receiving Data from DDS */
while (1)
{
status = bpReader->take(
bpList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < bpList.length(); i++)
{
if(infoSeq[i].valid_data)
{
prtemp <<bpList[i].deviceDomain<<COMMA;
prtemp <<bpList[i].deviceID <<COMMA<<bpList[i].timeOfMeasurement<<COMMA<< bpList[i].systolicPressure;
prtemp <<COMMA<<bpList[i].diastolicPressure<<COMMA<<bpList[i].pulseRatePerMinute;
bloodEcho.info(prtemp.str().c_str());
prtemp.str(CLEAN);
}
}
status = bpReader->return_loan(bpList, infoSeq);
checkStatus(status, "return_loan");
}
/* We're done. Delete everything */
bloodInfo.notice("Blood Pressure Subscriber Ends");
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}
bool
Ice::ObjectAdapterI::filterProperties(StringSeq& unknownProps)
{
static const string suffixes[] =
{
"ACM",
"ACM.Close",
"ACM.Heartbeat",
"ACM.Timeout",
"AdapterId",
"Endpoints",
"Locator",
"Locator.EncodingVersion",
"Locator.EndpointSelection",
"Locator.ConnectionCached",
"Locator.PreferSecure",
"Locator.CollocationOptimized",
"Locator.Router",
"MessageSizeMax",
"PublishedEndpoints",
"ReplicaGroupId",
"Router",
"Router.EncodingVersion",
"Router.EndpointSelection",
"Router.ConnectionCached",
"Router.PreferSecure",
"Router.CollocationOptimized",
"Router.Locator",
"Router.Locator.EndpointSelection",
"Router.Locator.ConnectionCached",
"Router.Locator.PreferSecure",
"Router.Locator.CollocationOptimized",
"Router.Locator.LocatorCacheTimeout",
"Router.Locator.InvocationTimeout",
"Router.LocatorCacheTimeout",
"Router.InvocationTimeout",
"ProxyOptions",
"ThreadPool.Size",
"ThreadPool.SizeMax",
"ThreadPool.SizeWarn",
"ThreadPool.StackSize",
"ThreadPool.Serialize",
"ThreadPool.ThreadPriority"
};
//
// Do not create unknown properties list if Ice prefix, ie Ice, Glacier2, etc
//
bool addUnknown = true;
string prefix = _name + ".";
for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i)
{
string icePrefix = string(*i) + ".";
if(prefix.find(icePrefix) == 0)
{
addUnknown = false;
break;
}
}
bool noProps = true;
PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix);
for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
{
bool valid = false;
for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i)
{
string prop = prefix + suffixes[i];
if(p->first == prop)
{
noProps = false;
valid = true;
break;
}
}
if(!valid && addUnknown)
{
unknownProps.push_back(p->first);
}
}
return noProps;
}
int main(int argc, char* argv[])
{
if (!parse_args_sub(argc, argv,domainid,deviceid,loginfo,logdata,logconfpath))
return 1;
/*Importing log4cpp configuration and Creating category*/
log4cpp::Category &log_root = log4cpp::Category::getRoot();
log4cpp::Category &bloodInfo = log4cpp::Category::getInstance( std::string(loginfo));
log4cpp::Category &bloodEcho = log4cpp::Category::getInstance( std::string(logdata));
log4cpp::PropertyConfigurator::configure(logconfpath);
bloodInfo.notice(" ecg Subscriber Started " +deviceid);
/*Initializing SimpleDDS library*/
SimpleDDS *simpledds;
ECGTypeSupport_var typesupport;
DataReader_ptr content_reader;
ECGDataReader_var ecgReader;
ReturnCode_t status;
int i=0;
/*Setting QoS Properties for Topic*/
/*DDS::TopicQos tQos;
tQos.durability.kind=PERSISTENT_DURABILITY_QOS;
DDS::Duration_t cleanup_delay = {0, 0};
tQos.durability_service.service_cleanup_delay = cleanup_delay;
tQos.durability_service.history_depth=1;
tQos.durability_service.max_samples=1;
tQos.durability_service.max_instances=1;
tQos.durability_service.max_samples_per_instance=1;
tQos.reliability.kind=RELIABLE_RELIABILITY_QOS;
DDS::Duration_t tempdura = {500, 0};
tQos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
tQos.liveliness.lease_duration = tempdura;
tQos.lifespan.duration=tempdura;
tQos.reliability.synchronous=true;
tQos.history.kind=KEEP_ALL_HISTORY_QOS;
tQos.history.depth=LENGTH_UNLIMITED;
tQos.resource_limits.max_samples=LENGTH_UNLIMITED;
tQos.resource_limits.max_instances=LENGTH_UNLIMITED;
tQos.resource_limits.max_samples_per_instance=LENGTH_UNLIMITED;*/
//getQos(tQos);
//tQos.durability_service.history_depth= 1024;
/*Initializing Subscriber and DataWriter*/
simpledds = new SimpleDDS();
typesupport = new ECGTypeSupport();
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
ecgReader = ECGDataReader::_narrow(content_reader);
ECGSeq ecgList;
SampleInfoSeq infoSeq;
int m_count=0;
bloodInfo.notice("ecg Subscriber For "+deviceid);
bloodInfo.notice("Format: DOMAIN, DEVICEID, TIMEOFMEASURED, TimeInSeconds, AmplitudeMillivolts, WaveformPeak, StandardDeviation, Signal");
/*Receiving Data from DDS */
while (1)
{
status = ecgReader->take(
ecgList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < ecgList.length(); i++)
{
if(infoSeq[i].valid_data)
{
prtemp <<ecgList[i].deviceDomain<<COMMA;
prtemp <<ecgList[i].deviceID <<COMMA<<ecgList[i].timeOfMeasurement<<COMMA<< ecgList[i].timeInSeconds;
prtemp <<COMMA<<ecgList[i].amplitudeMillivolts<<COMMA<<ecgList[i].waveformPeak;
prtemp <<COMMA<<ecgList[i].standardDeviation<<COMMA<<ecgList[i].signalECG;
bloodEcho.info(prtemp.str().c_str());
prtemp.str(CLEAN);
cout << m_count<<"\n";
m_count++;
}
}
status = ecgReader->return_loan(ecgList, infoSeq);
checkStatus(status, "return_loan");
}
/* We're done. Delete everything */
bloodInfo.notice("ecg Subscriber Ends");
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}
Ice::ObjectAdapterI::ObjectAdapterI(const InstancePtr& instance, const CommunicatorPtr& communicator,
const ObjectAdapterFactoryPtr& objectAdapterFactory, const string& name,
const string& endpointInfo, const RouterPrx& router, bool noConfig) :
_deactivated(false),
_instance(instance),
_communicator(communicator),
_objectAdapterFactory(objectAdapterFactory),
_servantManager(new ServantManager(instance, name)),
_activateOneOffDone(false),
_name(name),
_directCount(0),
_waitForActivate(false),
_destroying(false),
_destroyed(false),
_noConfig(noConfig),
_threadPerConnection(false),
_threadPerConnectionStackSize(0)
{
if(_noConfig)
{
return;
}
PropertiesPtr properties = instance->initializationData().properties;
StringSeq unknownProps;
bool noProps = filterProperties(unknownProps);
//
// Warn about unknown object adapter properties.
//
if(unknownProps.size() != 0 && properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
Warning out(_instance->initializationData().logger);
out << "found unknown properties for object adapter '" << _name << "':";
for(unsigned int i = 0; i < unknownProps.size(); ++i)
{
out << "\n " << unknownProps[i];
}
}
//
// Make sure named adapter has some configuration
//
if(endpointInfo.empty() && router == 0 && noProps)
{
InitializationException ex(__FILE__, __LINE__);
ex.reason = "object adapter \"" + _name + "\" requires configuration.";
throw ex;
}
const_cast<string&>(_id) = properties->getProperty(_name + ".AdapterId");
const_cast<string&>(_replicaGroupId) = properties->getProperty(_name + ".ReplicaGroupId");
__setNoDelete(true);
try
{
_threadPerConnection = properties->getPropertyAsInt(_name + ".ThreadPerConnection") > 0;
int threadPoolSize = properties->getPropertyAsInt(_name + ".ThreadPool.Size");
int threadPoolSizeMax = properties->getPropertyAsInt(_name + ".ThreadPool.SizeMax");
if(_threadPerConnection && (threadPoolSize > 0 || threadPoolSizeMax > 0))
{
InitializationException ex(__FILE__, __LINE__);
ex.reason = "object adapter \"" + _name + "\" cannot be configured for both\n"
"thread pool and thread per connection";
throw ex;
}
if(!_threadPerConnection && threadPoolSize == 0 && threadPoolSizeMax == 0)
{
_threadPerConnection = _instance->threadPerConnection();
}
if(_threadPerConnection)
{
int stackSize =
properties->getPropertyAsIntWithDefault(_name + ".ThreadPerConnection.StackSize",
static_cast<Int>(_instance->threadPerConnectionStackSize()));
if(stackSize < 0)
{
stackSize = 0;
}
_threadPerConnectionStackSize = stackSize;
}
//
// Create the per-adapter thread pool, if necessary. This is done before the creation of the incoming
// connection factory as the thread pool is needed during creation for the call to incFdsInUse.
//
if(threadPoolSize > 0 || threadPoolSizeMax > 0)
{
_threadPool = new ThreadPool(_instance, _name + ".ThreadPool", 0);
}
if(!router)
{
const_cast<RouterPrx&>(router) = RouterPrx::uncheckedCast(
_instance->proxyFactory()->propertyToProxy(_name + ".Router"));
}
if(router)
{
_routerInfo = _instance->routerManager()->get(router);
if(_routerInfo)
{
//
// Make sure this router is not already registered with another adapter.
//
if(_routerInfo->getAdapter())
{
throw AlreadyRegisteredException(__FILE__, __LINE__, "object adapter with router",
_instance->identityToString(router->ice_getIdentity()));
}
//
// Add the router's server proxy endpoints to this object
// adapter.
//
vector<EndpointIPtr> endpoints = _routerInfo->getServerEndpoints();
copy(endpoints.begin(), endpoints.end(), back_inserter(_routerEndpoints));
sort(_routerEndpoints.begin(), _routerEndpoints.end()); // Must be sorted.
_routerEndpoints.erase(unique(_routerEndpoints.begin(), _routerEndpoints.end()),
_routerEndpoints.end());
//
// Associate this object adapter with the router. This way,
// new outgoing connections to the router's client proxy will
// use this object adapter for callbacks.
//
_routerInfo->setAdapter(this);
//
// Also modify all existing outgoing connections to the
// router's client proxy to use this object adapter for
// callbacks.
//
_instance->outgoingConnectionFactory()->setRouterInfo(_routerInfo);
}
}
else
{
//
// Parse the endpoints, but don't store them in the adapter.
// The connection factory might change it, for example, to
// fill in the real port number.
//
vector<EndpointIPtr> endpoints;
if(endpointInfo.empty())
{
endpoints = parseEndpoints(properties->getProperty(_name + ".Endpoints"));
}
else
{
endpoints = parseEndpoints(endpointInfo);
}
for(vector<EndpointIPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
_incomingConnectionFactories.push_back(new IncomingConnectionFactory(instance, *p, this, _name));
}
if(endpoints.empty())
{
TraceLevelsPtr tl = _instance->traceLevels();
if(tl->network >= 2)
{
Trace out(_instance->initializationData().logger, tl->networkCat);
out << "created adapter `" << name << "' without endpoints";
}
}
//
// Parse published endpoints. If set, these are used in proxies
// instead of the connection factory endpoints.
//
string endpts = properties->getProperty(_name + ".PublishedEndpoints");
_publishedEndpoints = parseEndpoints(endpts);
if(_publishedEndpoints.empty())
{
transform(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
back_inserter(_publishedEndpoints), Ice::constMemFun(&IncomingConnectionFactory::endpoint));
}
//
// Filter out any endpoints that are not meant to be published.
//
_publishedEndpoints.erase(remove_if(_publishedEndpoints.begin(), _publishedEndpoints.end(),
not1(Ice::constMemFun(&EndpointI::publish))), _publishedEndpoints.end());
}
if(!properties->getProperty(_name + ".Locator").empty())
{
setLocator(LocatorPrx::uncheckedCast(_instance->proxyFactory()->propertyToProxy(_name + ".Locator")));
}
else
{
setLocator(_instance->referenceFactory()->getDefaultLocator());
}
}
catch(...)
{
destroy();
__setNoDelete(false);
throw;
}
__setNoDelete(false);
}
int alarmSubscribePulseOximeter(string domainid,string deviceid,string loginfo,string logdata,string logconfpath,int splow,int sphigh,int pulselow,int pulsehigh)
{
/*Initializing SimpleDDS library*/
DataService *simpledds;
PulseOximeterTypeSupport_var typesupport;
DataReader_ptr content_reader;
PulseOximeterDataReader_var bpReader;
ReturnCode_t status;
int i=0;
simpledds->logger->info(" PulseOximeter Alarm Subscriber Started");
/*Setting QoS Properties for Topic*/
DDS::TopicQos tQos;
getQos(tQos);
simpledds = new OpenSpliceDataService(tQos,loginfo,logconfpath);
typesupport = new PulseOximeterTypeSupport();
simpledds->logger->info(" PulseOximeter Alarm Subscriber Started");
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
bpReader = PulseOximeterDataReader::_narrow(content_reader);
PulseOximeterSeq bpList;
SampleInfoSeq infoSeq;
simpledds->logger->info("pulse Oximeter Alarm Subscriber for %s",deviceid.c_str());
simpledds->logger->info("Format: DOMAIN_ID, DEVICE_ID, MEASURED_TIME, SPO2 (LEVEL), PUSLERATE (LEVEL)");
/*Receiving Data from DDS */
while (1)
{
status = bpReader->take(
bpList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < bpList.length(); i++)
{
if(infoSeq[i].valid_data)
{
if (bpList[i].SPO2 < splow || bpList[i].SPO2 > sphigh || bpList[i].pulseRatePerMinute < pulselow || bpList[i].pulseRatePerMinute > pulsehigh)
{
prtemp <<bpList[i].deviceDomain<<COMMA<<bpList[i].deviceID<<COMMA<<bpList[i].timeOfMeasurement<<COMMA;
prtemp <<alarmString(bpList[i].SPO2,splow,sphigh)<<COMMA<<alarmString(bpList[i].pulseRatePerMinute,pulselow,pulsehigh);
simpledds->logger->info(prtemp.str().c_str());
prtemp.str(CLEAN);
}
}
}
status = bpReader->return_loan(bpList, infoSeq);
checkStatus(status, "return_loan");
}
simpledds->logger->info("PulseOximeter Alarm Subscriber Ends %s",deviceid.c_str());
/* We're done. Delete everything */
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}
void
Transceiver::create(const transceiverDef& def)
{
m_def = def;
// cout << "Transceiver::create(" << partition_id() << ", " << m_def.transceiver_id << ")" << endl;
// setup QueryCondition for reading this Transceiver's Qos
stringstream id;
id << m_def.transceiver_id;
StringSeq params;
params.length(1);
params[0] = id.str().c_str();
m_qos_query.create(ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE,
"transceiver_id = %0",
params);
// setup Transceiver topic
set_topics();
// read initial Qos
transceiverQosSeq qoss;
SampleInfoSeq infos;
// REVISIT - read or take?
ReturnCode_t retcode = qos_reader()->read_w_condition(qoss,
infos,
1,
m_qos_query);
if (retcode == RETCODE_NO_DATA)
{
// no Qos instance to read, so initialize and write
m_qos.group_id = m_def.group_id;
m_qos.transceiver_id = m_def.transceiver_id;
m_qos.partition_id = m_def.partition_id;
m_qos.writer_qos.latency_budget.duration.sec = 0;
m_qos.writer_qos.latency_budget.duration.nanosec = 0;
m_qos.writer_qos.transport_priority.value = 0;
m_qos.reader_qos.history.depth = 1;
m_qos.reader_qos.latency_budget.duration.sec = 0;
m_qos.reader_qos.latency_budget.duration.nanosec = 0;
retcode = qos_writer()->write(m_qos,
0);
qos_writer().check(retcode,
"transceiverQosDataWriter::write");
}
else
{
qos_reader().check(retcode,
"transceiverQosDataReader::read_w_condition");
assert(qoss.length() == 1);
assert(infos.length() == 1);
m_qos = qoss[0];
assert(m_qos.group_id == m_def.group_id);
assert(m_qos.transceiver_id == m_def.transceiver_id);
assert(m_qos.partition_id == m_def.partition_id);
}
qos_reader()->return_loan(qoss,
infos);
set_qos();
// start threads
m_writer_active = true;
m_writer_thread.create(&Transceiver::writer_thread);
m_reader_active = true;
m_reader_thread.create(&Transceiver::reader_thread);
m_report_active = true;
m_report_thread.create(&Transceiver::report_thread);
}
//string domainid,deviceid,loginfo,logdata,logconfpath;
int echoSubscribeBloodPressure(string domainid,string deviceid,string loginfo,string logdata,string logconfpath)
{
/*Initializing SimpleDDS library*/
DataService *simpledds;
BloodPressureTypeSupport_var typesupport;
DataReader_ptr content_reader;
BloodPressureDataReader_var bpReader;
ReturnCode_t status;
int i=0;
/*Setting QoS Properties for Topic*/
DDS::TopicQos tQos;
getQos(tQos);
tQos.durability_service.history_depth= 1024;
/*Initializing Subscriber and DataWriter*/
simpledds = new OpenSpliceDataService(tQos,loginfo,logconfpath);
typesupport = new BloodPressureTypeSupport();
simpledds->logger->info(" Blood Pressure Subscriber Started %s" ,deviceid.c_str());
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
bpReader = BloodPressureDataReader::_narrow(content_reader);
BloodPressureSeq bpList;
SampleInfoSeq infoSeq;
simpledds->logger->info("Blood Pressure Subscriber For %s",deviceid.c_str());
simpledds->logger->info("Format: DOMAIN_ID, DEVICE_ID, MEASURED_TIME, SYSTOLIC, DIASTOLIC, PULSERATE");
/*Receiving Data from DDS */
while (1)
{
status = bpReader->take(
bpList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < bpList.length(); i++)
{
if(infoSeq[i].valid_data)
{
prtemp <<bpList[i].deviceDomain<<COMMA;
prtemp <<bpList[i].deviceID <<COMMA<<bpList[i].timeOfMeasurement<<COMMA<< bpList[i].systolicPressure;
prtemp <<COMMA<<bpList[i].diastolicPressure<<COMMA<<bpList[i].pulseRatePerMinute;
simpledds->logger->info(prtemp.str().c_str());
prtemp.str(CLEAN);
}
}
status = bpReader->return_loan(bpList, infoSeq);
checkStatus(status, "return_loan");
}
/* We're done. Delete everything */
simpledds->logger->info("Blood Pressure Subscriber Ends");
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}
void
Ice::ObjectAdapterI::initialize(const RouterPrx& router)
{
if(_noConfig)
{
_reference = _instance->referenceFactory()->create("dummy -t", "");
return;
}
PropertiesPtr properties = _instance->initializationData().properties;
StringSeq unknownProps;
bool noProps = filterProperties(unknownProps);
//
// Warn about unknown object adapter properties.
//
if(unknownProps.size() != 0 && properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
Warning out(_instance->initializationData().logger);
out << "found unknown properties for object adapter `" << _name << "':";
for(unsigned int i = 0; i < unknownProps.size(); ++i)
{
out << "\n " << unknownProps[i];
}
}
try
{
//
// Make sure named adapter has some configuration
//
if(router == 0 && noProps)
{
InitializationException ex(__FILE__, __LINE__);
ex.reason = "object adapter `" + _name + "' requires configuration";
throw ex;
}
const_cast<string&>(_id) = properties->getProperty(_name + ".AdapterId");
const_cast<string&>(_replicaGroupId) = properties->getProperty(_name + ".ReplicaGroupId");
//
// Setup a reference to be used to get the default proxy options
// when creating new proxies. By default, create twoway proxies.
//
string proxyOptions = properties->getPropertyWithDefault(_name + ".ProxyOptions", "-t");
try
{
_reference = _instance->referenceFactory()->create("dummy " + proxyOptions, "");
}
catch(const ProxyParseException&)
{
InitializationException ex(__FILE__, __LINE__);
ex.reason = "invalid proxy options `" + proxyOptions + "' for object adapter `" + _name + "'";
throw ex;
}
int threadPoolSize = properties->getPropertyAsInt(_name + ".ThreadPool.Size");
int threadPoolSizeMax = properties->getPropertyAsInt(_name + ".ThreadPool.SizeMax");
bool hasPriority = properties->getProperty(_name + ".ThreadPool.ThreadPriority") != "";
//
// Create the per-adapter thread pool, if necessary. This is done before the creation of the incoming
// connection factory as the thread pool is needed during creation for the call to incFdsInUse.
//
if(threadPoolSize > 0 || threadPoolSizeMax > 0 || hasPriority)
{
_threadPool = new ThreadPool(_instance, _name + ".ThreadPool", 0);
}
_hasAcmTimeout = properties->getProperty(_name + ".ACM") != "";
if(_hasAcmTimeout)
{
_acmTimeout = properties->getPropertyAsInt(_name + ".ACM");
_instance->connectionMonitor()->checkIntervalForACM(_acmTimeout);
}
if(!router)
{
const_cast<RouterPrx&>(router) = RouterPrx::uncheckedCast(
_instance->proxyFactory()->propertyToProxy(_name + ".Router"));
}
if(router)
{
_routerInfo = _instance->routerManager()->get(router);
if(_routerInfo)
{
//
// Make sure this router is not already registered with another adapter.
//
if(_routerInfo->getAdapter())
{
throw AlreadyRegisteredException(__FILE__, __LINE__, "object adapter with router",
_instance->identityToString(router->ice_getIdentity()));
}
//
// Add the router's server proxy endpoints to this object
// adapter.
//
vector<EndpointIPtr> endpoints = _routerInfo->getServerEndpoints();
copy(endpoints.begin(), endpoints.end(), back_inserter(_routerEndpoints));
sort(_routerEndpoints.begin(), _routerEndpoints.end()); // Must be sorted.
_routerEndpoints.erase(unique(_routerEndpoints.begin(), _routerEndpoints.end()),
_routerEndpoints.end());
//
// Associate this object adapter with the router. This way,
// new outgoing connections to the router's client proxy will
// use this object adapter for callbacks.
//
_routerInfo->setAdapter(this);
//
// Also modify all existing outgoing connections to the
// router's client proxy to use this object adapter for
// callbacks.
//
_instance->outgoingConnectionFactory()->setRouterInfo(_routerInfo);
}
}
else
{
//
// Parse the endpoints, but don't store them in the adapter.
// The connection factory might change it, for example, to
// fill in the real port number.
//
vector<EndpointIPtr> endpoints = parseEndpoints(properties->getProperty(_name + ".Endpoints"), true);
for(vector<EndpointIPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
IncomingConnectionFactoryPtr factory = new IncomingConnectionFactory(_instance, *p, this);
factory->initialize(_name);
_incomingConnectionFactories.push_back(factory);
}
if(endpoints.empty())
{
TraceLevelsPtr tl = _instance->traceLevels();
if(tl->network >= 2)
{
Trace out(_instance->initializationData().logger, tl->networkCat);
out << "created adapter `" << _name << "' without endpoints";
}
}
//
// Parse the published endpoints.
//
_publishedEndpoints = parsePublishedEndpoints();
}
if(!properties->getProperty(_name + ".Locator").empty())
{
setLocator(LocatorPrx::uncheckedCast(_instance->proxyFactory()->propertyToProxy(_name + ".Locator")));
}
else
{
setLocator(_instance->referenceFactory()->getDefaultLocator());
}
}
catch(...)
{
destroy();
throw;
}
}
int
Activator::activate(const string& name,
const string& exePath,
const string& pwdPath,
#ifndef _WIN32
uid_t uid,
gid_t gid,
#endif
const Ice::StringSeq& options,
const Ice::StringSeq& envs,
const ServerIPtr& server)
{
IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this);
if(_deactivating)
{
throw string("The node is being shutdown.");
}
string path = exePath;
if(path.empty())
{
throw string("The server executable path is empty.");
}
string pwd = IcePatch2Internal::simplify(pwdPath);
#ifdef _WIN32
if(!IceUtilInternal::isAbsolutePath(path))
{
if(path.find('/') == string::npos)
{
//
// Get the absolute pathname of the executable.
//
wchar_t absbuf[_MAX_PATH];
wchar_t* fPart;
wstring ext = path.size() <= 4 || path[path.size() - 4] != '.' ? L".exe" : L"";
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in wstringToString conversions.
//
if(SearchPathW(NULL, IceUtil::stringToWstring(path).c_str(), ext.c_str(), _MAX_PATH, absbuf, &fPart) == 0)
{
if(_traceLevels->activator > 0)
{
Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "couldn't find `" << path << "' executable.";
}
throw string("Couldn't find `" + path + "' executable.");
}
path = IceUtil::wstringToString(absbuf);
}
else if(!pwd.empty())
{
path = pwd + "/" + path;
}
}
//
// Get the absolute pathname of the working directory.
//
// IceGrid doesn't support to use string converters, so
// don't need to use any string converter in stringToWstring
// conversions.
//
if(!pwd.empty())
{
wchar_t absbuf[_MAX_PATH];
if(_wfullpath(absbuf, IceUtil::stringToWstring(pwd).c_str(), _MAX_PATH) == NULL)
{
if(_traceLevels->activator > 0)
{
Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "cannot convert `" << pwd << "' into an absolute path";
}
throw string("The server working directory path `" + pwd + "' can't be converted into an absolute path.");
}
pwd = IceUtil::wstringToString(absbuf);
}
#endif
//
// Setup arguments.
//
StringSeq args;
args.push_back(path);
args.insert(args.end(), options.begin(), options.end());
if(_traceLevels->activator > 0)
{
Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "activating server `" << name << "'";
if(_traceLevels->activator > 1)
{
out << "\n";
out << "path = " << path << "\n";
if(pwd.empty())
{
string cwd;
if(IceUtilInternal::getcwd(cwd) == 0)
{
out << "pwd = " << cwd << "\n";
}
}
else
{
out << "pwd = " << pwd << "\n";
}
#ifndef _WIN32
out << "uid/gid = " << uid << "/" << gid << "\n";
#endif
if(!envs.empty())
{
out << "envs = " << toString(envs, ", ") << "\n";
}
if(!args.empty())
{
out << "args = " << toString(args);
}
}
}
//
// Activate and create.
//
#ifdef _WIN32
//
// Compose command line.
//
string cmd;
for(StringSeq::const_iterator p = args.begin(); p != args.end(); ++p)
{
if(p != args.begin())
{
cmd.push_back(' ');
}
//
// Enclose arguments containing spaces in double quotes.
//
if((*p).find(' ') != string::npos)
{
cmd.push_back('"');
cmd.append(*p);
cmd.push_back('"');
}
else
{
cmd.append(*p);
}
}
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in stringToWstring conversions.
//
wstring wpwd = IceUtil::stringToWstring(pwd);
const wchar_t* dir = !wpwd.empty() ? wpwd.c_str() : NULL;
//
// Make a copy of the command line.
//
wchar_t* cmdbuf = _wcsdup(IceUtil::stringToWstring(cmd).c_str());
//
// Create the environment block for the child process. We start with the environment
// of this process, and then merge environment variables from the server description.
// Since Windows is case insensitive wrt environment variables we convert the keys to
// uppercase to ensure matches are found.
//
const wchar_t* env = NULL;
wstring envbuf;
if(!envs.empty())
{
map<wstring, wstring, UnicodeStringLess> envMap;
LPVOID parentEnv = GetEnvironmentStringsW();
const wchar_t* var = reinterpret_cast<const wchar_t*>(parentEnv);
if(*var == L'=')
{
//
// The environment block may start with some information about the
// current drive and working directory. This is indicated by a leading
// '=' character, so we skip to the first '\0' byte.
//
while(*var != L'\0')
var++;
var++;
}
while(*var != L'\0')
{
wstring s(var);
wstring::size_type pos = s.find(L'=');
if(pos != wstring::npos)
{
envMap[s.substr(0, pos)] = s.substr(pos + 1);
}
var += s.size();
var++; // Skip the '\0' byte
}
FreeEnvironmentStringsW(static_cast<wchar_t*>(parentEnv));
for(StringSeq::const_iterator p = envs.begin(); p != envs.end(); ++p)
{
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in stringToWstring conversions.
//
wstring s = IceUtil::stringToWstring(*p);
wstring::size_type pos = s.find(L'=');
if(pos != wstring::npos)
{
envMap[s.substr(0, pos)] = s.substr(pos + 1);
}
}
for(map<wstring, wstring, UnicodeStringLess>::const_iterator q = envMap.begin(); q != envMap.end(); ++q)
{
envbuf.append(q->first);
envbuf.push_back(L'=');
envbuf.append(q->second);
envbuf.push_back(L'\0');
}
envbuf.push_back(L'\0');
env = envbuf.c_str();
}
Process process;
STARTUPINFOW si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
BOOL b = CreateProcessW(
NULL, // Executable
cmdbuf, // Command line
NULL, // Process attributes
NULL, // Thread attributes
FALSE, // Do NOT inherit handles
CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT, // Process creation flags
(LPVOID)env, // Process environment
dir, // Current directory
&si, // Startup info
&pi // Process info
);
free(cmdbuf);
if(!b)
{
throw IceUtilInternal::lastErrorToString();
}
//
// Caller is responsible for closing handles in PROCESS_INFORMATION. We don't need to
// keep the thread handle, so we close it now. The process handle will be closed later.
//
CloseHandle(pi.hThread);
process.activator = this;
process.pid = pi.dwProcessId;
process.hnd = pi.hProcess;
process.server = server;
map<string, Process>::iterator it = _processes.insert(make_pair(name, process)).first;
Process* pp = &it->second;
if(!RegisterWaitForSingleObject(&pp->waithnd, pp->hnd, activatorWaitCallback, pp, INFINITE,
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE))
{
throw IceUtilInternal::lastErrorToString();
}
//
// Don't print the following trace, this might interfer with the
// output of the started process if it fails with an error message.
//
// if(_traceLevels->activator > 0)
// {
// Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
// out << "activated server `" << name << "' (pid = " << pi.dwProcessId << ")";
// }
return static_cast<Ice::Int>(process.pid);
#else
int fds[2];
if(pipe(fds) != 0)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
int errorFds[2];
if(pipe(errorFds) != 0)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
//
// Convert to standard argc/argv.
//
IceUtilInternal::ArgVector av(args);
IceUtilInternal::ArgVector env(envs);
//
// Current directory
//
const char* pwdCStr = pwd.c_str();
pid_t pid = fork();
if(pid == -1)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
if(pid == 0) // Child process.
{
//
// Until exec, we can only use async-signal safe functions
//
//
// Unblock signals blocked by IceUtil::CtrlCHandler.
//
sigset_t sigs;
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);
sigaddset(&sigs, SIGINT);
sigaddset(&sigs, SIGTERM);
sigprocmask(SIG_UNBLOCK, &sigs, 0);
//
// Change the uid/gid under which the process will run.
//
if(setgid(gid) == -1)
{
ostringstream os;
os << gid;
reportChildError(getSystemErrno(), errorFds[1], "cannot set process group id", os.str().c_str(),
_traceLevels);
}
errno = 0;
struct passwd* pw = getpwuid(uid);
if(!pw)
{
if(errno)
{
reportChildError(getSystemErrno(), errorFds[1], "cannot read the password database", "",
_traceLevels);
}
else
{
ostringstream os;
os << uid;
reportChildError(getSystemErrno(), errorFds[1], "unknown user uid" , os.str().c_str(),
_traceLevels);
}
}
//
// Don't initialize supplementary groups if we are not running as root.
//
if(getuid() == 0 && initgroups(pw->pw_name, gid) == -1)
{
ostringstream os;
os << pw->pw_name;
reportChildError(getSystemErrno(), errorFds[1], "cannot initialize process supplementary group access list for user",
os.str().c_str(), _traceLevels);
}
if(setuid(uid) == -1)
{
ostringstream os;
os << uid;
reportChildError(getSystemErrno(), errorFds[1], "cannot set process user id", os.str().c_str(),
_traceLevels);
}
//
// Assign a new process group for this process.
//
setpgid(0, 0);
//
// Close all file descriptors, except for standard input,
// standard output, standard error, and the write side
// of the newly created pipe.
//
int maxFd = static_cast<int>(sysconf(_SC_OPEN_MAX));
for(int fd = 3; fd < maxFd; ++fd)
{
if(fd != fds[1] && fd != errorFds[1])
{
close(fd);
}
}
for(int i = 0; i < env.argc; i++)
{
//
// Each env is leaked on purpose ... see man putenv().
//
if(putenv(strdup(env.argv[i])) != 0)
{
reportChildError(errno, errorFds[1], "cannot set environment variable", env.argv[i],
_traceLevels);
}
}
//
// Change working directory.
//
if(strlen(pwdCStr) != 0)
{
if(chdir(pwdCStr) == -1)
{
reportChildError(errno, errorFds[1], "cannot change working directory to", pwdCStr,
_traceLevels);
}
}
//
// Close on exec the error message file descriptor.
//
int flags = fcntl(errorFds[1], F_GETFD);
flags |= 1; // FD_CLOEXEC
if(fcntl(errorFds[1], F_SETFD, flags) == -1)
{
close(errorFds[1]);
errorFds[1] = -1;
}
if(execvp(av.argv[0], av.argv) == -1)
{
if(errorFds[1] != -1)
{
reportChildError(errno, errorFds[1], "cannot execute", av.argv[0], _traceLevels);
}
else
{
reportChildError(errno, fds[1], "cannot execute", av.argv[0], _traceLevels);
}
}
}
else // Parent process.
{
close(fds[1]);
close(errorFds[1]);
//
// Read a potential error message over the error message pipe.
//
char s[16];
ssize_t rs;
string message;
while((rs = read(errorFds[0], &s, 16)) > 0)
{
message.append(s, rs);
}
//
// If an error occured before the exec() we do some cleanup and throw.
//
if(!message.empty())
{
close(fds[0]);
close(errorFds[0]);
waitPid(pid);
throw message;
}
//
// Otherwise, the exec() was successfull and we don't need the error message
// pipe anymore.
//
close(errorFds[0]);
Process process;
process.pid = pid;
process.pipeFd = fds[0];
process.server = server;
_processes.insert(make_pair(name, process));
int flags = fcntl(process.pipeFd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(process.pipeFd, F_SETFL, flags);
setInterrupt();
//
// Don't print the following trace, this might interfere with the
// output of the started process if it fails with an error message.
//
// if(_traceLevels->activator > 0)
// {
// Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
// out << "activated server `" << name << "' (pid = " << pid << ")";
// }
}
return pid;
#endif
}
bool
IceBox::ServiceManagerI::start()
{
try
{
ServiceManagerPtr obj = this;
PropertiesPtr properties = _communicator->getProperties();
//
// Create an object adapter. Services probably should NOT share
// this object adapter, as the endpoint(s) for this object adapter
// will most likely need to be firewalled for security reasons.
//
ObjectAdapterPtr adapter;
if(properties->getProperty("IceBox.ServiceManager.Endpoints") != "")
{
adapter = _communicator->createObjectAdapter("IceBox.ServiceManager");
Identity identity;
identity.category = properties->getPropertyWithDefault("IceBox.InstanceName", "IceBox");
identity.name = "ServiceManager";
adapter->add(obj, identity);
}
//
// Parse the property set with the prefix "IceBox.Service.". These
// properties should have the following format:
//
// IceBox.Service.Foo=entry_point [args]
//
// We parse the service properties specified in IceBox.LoadOrder
// first, then the ones from remaining services.
//
const string prefix = "IceBox.Service.";
PropertyDict services = properties->getPropertiesForPrefix(prefix);
PropertyDict::iterator p;
StringSeq loadOrder = properties->getPropertyAsList("IceBox.LoadOrder");
vector<StartServiceInfo> servicesInfo;
for(StringSeq::const_iterator q = loadOrder.begin(); q != loadOrder.end(); ++q)
{
p = services.find(prefix + *q);
if(p == services.end())
{
FailureException ex(__FILE__, __LINE__);
ex.reason = "ServiceManager: no service definition for `" + *q + "'";
throw ex;
}
servicesInfo.push_back(StartServiceInfo(*q, p->second, _argv));
services.erase(p);
}
for(p = services.begin(); p != services.end(); ++p)
{
servicesInfo.push_back(StartServiceInfo(p->first.substr(prefix.size()), p->second, _argv));
}
//
// Check if some services are using the shared communicator in which
// case we create the shared communicator now with a property set which
// is the union of all the service properties (services which are using
// the shared communicator).
//
PropertyDict sharedCommunicatorServices = properties->getPropertiesForPrefix("IceBox.UseSharedCommunicator.");
if(!sharedCommunicatorServices.empty())
{
InitializationData initData;
initData.properties = createServiceProperties("SharedCommunicator");
for(vector<StartServiceInfo>::iterator q = servicesInfo.begin(); q != servicesInfo.end(); ++q)
{
if(properties->getPropertyAsInt("IceBox.UseSharedCommunicator." + q->name) <= 0)
{
continue;
}
//
// Load the service properties using the shared communicator properties as
// the default properties.
//
PropertiesPtr svcProperties = createProperties(q->args, initData.properties);
//
// Erase properties from the shared communicator which don't exist in the
// service properties (which include the shared communicator properties
// overriden by the service properties).
//
PropertyDict allProps = initData.properties->getPropertiesForPrefix("");
for(PropertyDict::iterator p = allProps.begin(); p != allProps.end(); ++p)
{
if(svcProperties->getProperty(p->first) == "")
{
initData.properties->setProperty(p->first, "");
}
}
//
// Add the service properties to the shared communicator properties.
//
PropertyDict props = svcProperties->getPropertiesForPrefix("");
for(PropertyDict::const_iterator r = props.begin(); r != props.end(); ++r)
{
initData.properties->setProperty(r->first, r->second);
}
//
// Parse <service>.* command line options (the Ice command line options
// were parsed by the createProperties above)
//
q->args = initData.properties->parseCommandLineOptions(q->name, q->args);
}
_sharedCommunicator = initialize(initData);
}
//
// Start the services.
//
for(vector<StartServiceInfo>::const_iterator r = servicesInfo.begin(); r != servicesInfo.end(); ++r)
{
start(r->name, r->entryPoint, r->args);
}
//
// We may want to notify external scripts that the services
// have started. This is done by defining the property:
//
// IceBox.PrintServicesReady=bundleName
//
// Where bundleName is whatever you choose to call this set of
// services. It will be echoed back as "bundleName ready".
//
// This must be done after start() has been invoked on the
// services.
//
string bundleName = properties->getProperty("IceBox.PrintServicesReady");
if(!bundleName.empty())
{
cout << bundleName << " ready" << endl;
}
//
// Register "this" as a facet to the Admin object, and then create
// Admin object
//
try
{
_communicator->addAdminFacet(this, "IceBox.ServiceManager");
//
// Add a Properties facet for each service
//
for(vector<ServiceInfo>::iterator r = _services.begin(); r != _services.end(); ++r)
{
const ServiceInfo& info = *r;
CommunicatorPtr communicator = info.communicator != 0 ? info.communicator : _sharedCommunicator;
_communicator->addAdminFacet(new PropertiesAdminI(communicator->getProperties()),
"IceBox.Service." + info.name + ".Properties");
}
_communicator->getAdmin();
}
catch(const ObjectAdapterDeactivatedException&)
{
//
// Expected if the communicator has been shutdown.
//
}
if(adapter)
{
try
{
adapter->activate();
}
catch(const ObjectAdapterDeactivatedException&)
{
//
// Expected if the communicator has been shutdown.
//
}
}
}
catch(const FailureException& ex)
{
Error out(_logger);
out << ex.reason;
stopAll();
return false;
}
catch(const Exception& ex)
{
Error out(_logger);
out << "ServiceManager: " << ex;
stopAll();
return false;
}
return true;
}
int main(int argc, char* argv[])
{
splow = 88;
sphigh = 92;
pulselow = 90;
pulsehigh = 105;
if (!parse_args_pulse_alarm(argc,argv,domainid,deviceid,loginfo,logdata,logconfpath,splow,sphigh,pulselow,pulsehigh))
return 1;
/*Importing log4cpp configuration and Creating category*/
log4cpp::Category &log_root = log4cpp::Category::getRoot();
log4cpp::Category &pulseInfo = log4cpp::Category::getInstance( std::string(loginfo));
log4cpp::Category &pulseAlarm = log4cpp::Category::getInstance( std::string(logdata));
log4cpp::PropertyConfigurator::configure(logconfpath);
pulseInfo.notice(" PulseOximeter Alarm Subscriber Started");
/*Initializing SimpleDDS library*/
SimpleDDS *simpledds;
PulseOximeterTypeSupport_var typesupport;
DataReader_ptr content_reader;
PulseOximeterDataReader_var bpReader;
ReturnCode_t status;
int i=0;
/*Setting QoS Properties for Topic*/
DDS::TopicQos tQos;
getQos(tQos);
simpledds = new SimpleDDS(tQos);
typesupport = new PulseOximeterTypeSupport();
/*Creating content Filtered Subscriber*/
StringSeq sSeqExpr;
sSeqExpr.length(0);
content_reader = simpledds->filteredSubscribe(typesupport, deviceid ,devid , deviceid,sSeqExpr);
bpReader = PulseOximeterDataReader::_narrow(content_reader);
PulseOximeterSeq bpList;
SampleInfoSeq infoSeq;
pulseInfo.notice("pulse Oximeter Alarm Subscriber for "+deviceid);
pulseInfo.notice("Format: DOMAIN_ID, DEVICE_ID, MEASURED_TIME, SPO2 (LEVEL), PUSLERATE (LEVEL)");
/*Receiving Data from DDS */
while (1)
{
status = bpReader->take(
bpList,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ANY_INSTANCE_STATE);
checkStatus(status, "take");
if (status == RETCODE_NO_DATA)
{
continue;
}
for (i = 0; i < bpList.length(); i++)
{
if(infoSeq[i].valid_data)
{
if (bpList[i].SPO2 < splow || bpList[i].SPO2 > sphigh || bpList[i].pulseRatePerMinute < pulselow || bpList[i].pulseRatePerMinute > pulsehigh)
{
prtemp <<bpList[i].deviceDomain<<COMMA<<bpList[i].deviceID<<COMMA<<bpList[i].timeOfMeasurement<<COMMA;
prtemp <<alarmString(bpList[i].SPO2,splow,sphigh)<<COMMA<<alarmString(bpList[i].pulseRatePerMinute,pulselow,pulsehigh);
pulseAlarm.info(prtemp.str().c_str());
prtemp.str(CLEAN);
}
}
}
status = bpReader->return_loan(bpList, infoSeq);
checkStatus(status, "return_loan");
}
pulseInfo.notice("PulseOximeter Alarm Subscriber Ends "+deviceid);
/* We're done. Delete everything */
simpledds->deleteReader(content_reader);
delete simpledds;
return 0;
}