void Subscription::UnSubscribe(std::vector<uint32_t> handles)
{
std::unique_lock<std::mutex> lock(Mutex);
DeleteMonitoredItemsParameters params;
params.SubscriptionId = Data.SubscriptionId;
std::vector<uint32_t> mids;
for (auto id : handles)
{
if (Debug) std::cout << "Subscription | Sending unsubscribe for monitoreditemsid: " << id << std::endl;
mids.push_back(uint32_t(id));
//Now trying to remove monitoreditem from our internal cache
for ( auto pair : AttributeValueMap )
{
if (pair.second.MonitoredItemId == id)
{
AttributeValueMap.erase(pair.first);
break; //we modified our iterating object, so quit!!
}
}
}
params.MonitoredItemIds = mids;
auto results = Server->Subscriptions()-> DeleteMonitoredItems(params);
for (auto res : results)
{
CheckStatusCode(res);
}
}
void Subscription::Delete()
{
std::vector<StatusCode> results = Server->Subscriptions()->DeleteSubscriptions(std::vector<uint32_t>{Data.SubscriptionId});
for (auto res: results)
{
CheckStatusCode(res);
}
}
void Subscription::Delete()
{
std::vector<StatusCode> results = Server->Subscriptions()->DeleteSubscriptions(std::vector<IntegerId>({Data.Id}));
for (auto res: results)
{
CheckStatusCode(res);
}
}
void Variable::SetValue(const DataValue& value)
{
WriteValue writeValue;
writeValue.Attribute = AttributeID::VALUE;
writeValue.Data = value;
writeValue.Node = Id;
std::vector<StatusCode> result = GetServices()->Attributes()->Write({writeValue});
if (result.size() != 1)
{
throw std::runtime_error("Failed to write data. Server returned wron nunber of status codes.");
}
CheckStatusCode(result[0]);
}
uint32_t Subscription::SubscribeEvents(const Node& node, const EventFilter& eventfilter)
{
std::unique_lock<std::mutex> lock(Mutex);
MonitoredItemsParameters itemsParams;
itemsParams.SubscriptionId = Data.SubscriptionId;
itemsParams.TimestampsToReturn = TimestampsToReturn(2); // Don't know for better
ReadValueId avid;
avid.NodeId = node.GetId();
avid.AttributeId = AttributeId::EventNotifier;
MonitoredItemCreateRequest req;
req.ItemToMonitor = avid;
req.MonitoringMode = MonitoringMode::Reporting;
MonitoringParameters params;
params.SamplingInterval = Data.RevisedPublishingInterval;
params.QueueSize = std::numeric_limits<uint32_t>::max();
params.DiscardOldest = true;
params.ClientHandle = (uint32_t)++LastMonitoredItemHandle;
MonitoringFilter filter(eventfilter);
params.Filter = filter;
req.RequestedParameters = params;
itemsParams.ItemsToCreate.push_back(req);
std::vector<MonitoredItemCreateResult> results = Server->Subscriptions()->CreateMonitoredItems(itemsParams);
if ( results.size() != 1 )
{
throw(std::runtime_error("Subscription | Protocol Error CreateMonitoredItems should return one result"));
}
MonitoredItemData mdata;
mdata.TargetNode = Node(Server, avid.NodeId);
mdata.Attribute = avid.AttributeId;
mdata.MonitoredItemId = results[0].MonitoredItemId;
mdata.Filter = results[0].FilterResult;
AttributeValueMap[params.ClientHandle] = mdata;
MonitoredItemCreateResult res = results[0];
CheckStatusCode(res.Status);
SimpleAttributeOperandMap[res.MonitoredItemId] = eventfilter; //Not used
return res.MonitoredItemId;
}
std::vector<uint32_t> Subscription::SubscribeDataChange(const std::vector<ReadValueId>& attributes)
{
std::unique_lock<std::mutex> lock(Mutex);
MonitoredItemsParameters itemsParams;
itemsParams.SubscriptionId = Data.SubscriptionId;
itemsParams.TimestampsToReturn = TimestampsToReturn(2); // Don't know for better
for (ReadValueId attr : attributes)
{
MonitoredItemCreateRequest req;
req.ItemToMonitor = attr;
req.MonitoringMode = MonitoringMode::Reporting;
MonitoringParameters params;
params.SamplingInterval = Data.RevisedPublishingInterval;
params.QueueSize = 1;
params.DiscardOldest = true;
params.ClientHandle = (uint32_t)++LastMonitoredItemHandle;
req.RequestedParameters = params;
itemsParams.ItemsToCreate.push_back(req);
}
std::vector<MonitoredItemCreateResult> results = Server->Subscriptions()->CreateMonitoredItems(itemsParams);
if ( results.size() != attributes.size() )
{
throw(std::runtime_error("Subscription | Error server did not send answer for all monitoreditem requests"));
}
std::vector<uint32_t> monitoredItemsIds;
unsigned int i = 0;
for (const auto& res : results)
{
CheckStatusCode(res.Status);
if (Debug ) { std::cout << "Subscription | storing monitoreditem with handle " << itemsParams.ItemsToCreate[i].RequestedParameters.ClientHandle << " and id " << res.MonitoredItemId << std::endl; }
MonitoredItemData mdata;
mdata.MonitoredItemId = res.MonitoredItemId;
mdata.Attribute = attributes[i].AttributeId;
mdata.TargetNode = Node(Server, attributes[i].NodeId);
AttributeValueMap[itemsParams.ItemsToCreate[i].RequestedParameters.ClientHandle] = mdata;
monitoredItemsIds.push_back(res.MonitoredItemId);
++i;
}
return monitoredItemsIds;
}
