c_bool
v_groupStreamSubscribe(
v_groupStream stream,
v_partition partition)
{
c_iter list;
v_kernel kernel;
c_value params[1];
v_group group;
assert(C_TYPECHECK(stream,v_groupStream));
kernel = v_objectKernel(v_entity(partition));
params[0] = c_objectValue(partition);
list = v_groupSetSelect(kernel->groupSet,"partition = %0 ",params);
group = c_iterTakeFirst(list);
while (group != NULL) {
v_groupStreamSubscribeGroup(stream, group);
c_free(group);
group = c_iterTakeFirst(list);
}
c_iterFree(list);
return TRUE;
}
/**************************************************************
* Protected functions
**************************************************************/
c_bool
v_readerSubscribeGroup(
v_reader _this,
v_group group)
{
c_bool result;
assert(C_TYPECHECK(_this, v_reader));
switch(v_objectKind(_this)) {
case K_DATAREADER:
/* ES, dds1576: For the K_DATAREADER object we need to verify if
* the access rights are correct. No subscriptions may be made onto
* groups which have a v_accessMode of write only.
*/
if(v_groupPartitionAccessMode(group) == V_ACCESS_MODE_READ_WRITE ||
v_groupPartitionAccessMode(group) == V_ACCESS_MODE_READ)
{
result = v_dataReaderSubscribeGroup(v_dataReader(_this), group);
readerGetHistoricalData(_this);
} else
{
result = FALSE;
}
break;
case K_GROUPQUEUE:
result = v_groupStreamSubscribeGroup(v_groupStream(_this), group);
break;
case K_NETWORKREADER:
result = v_networkReaderSubscribeGroup(v_networkReader(_this), group);
readerGetHistoricalData(_this);
break;
default:
OS_REPORT_1(OS_ERROR,"v_readerSubscribeGroup failed",0,
"illegal reader kind (%d) specified",
v_objectKind(_this));
assert(FALSE);
result = FALSE;
}
return result;
}
void
v_groupStreamConnectNewGroups(
v_groupStream stream,
v_group group)
{
struct groupConnected data;
assert(stream != NULL);
assert(C_TYPECHECK(stream,v_groupStream));
v_observerLock(v_observer(stream));
/*
* This means the group is interesting for this
* groupActionStream. Now I have to check if the stream is already
* connected to this group, because we wouldn't want to connect
* multiple times to one single group.
*/
data.connected = FALSE;
data.group = group;
c_walk(stream->groups, (c_action)isGroupConnected, &data);
if(data.connected == FALSE){
/*
* The stream is not connected to the group yet, so connect now.
*/
v_groupStreamSubscribeGroup(stream, group);
}
v_observerUnlock(v_observer(stream));
if(data.connected == FALSE){
v_groupStreamHistoricalData(group, stream);
}
return;
}
void
v_groupStreamNotify(
v_groupStream stream,
v_event e,
c_voidp userData)
{
struct groupConnected data;
c_iter partitions;
c_bool interested;
v_partition partition, found;
OS_UNUSED_ARG(userData);
assert(stream != NULL);
assert(C_TYPECHECK(stream,v_groupStream));
if (e) {
if (e->kind == V_EVENT_NEW_GROUP) {
v_observerLock(v_observer(stream));
/*
* Check if group fits interest. This extra steps are needed because
* the groupActionStream does not create the groups that match the
* subscriber qos partition expression on creation. It only needs to
* connect to new groups once they are created. This is a different
* approach then for a data reader.
*/
partition = v_group(e->userData)->partition;
/*
* Because already existing partitions are created and added to the
* subscriber of the groupActionStream at creation time, these
* partitions can be resolved from the subscriber. This is necessary to
* determine whether the groupActionStream should connect to the new
* group or if it is already connected.
*/
partitions = v_subscriberLookupPartitions(v_reader(stream)->subscriber,
v_partitionName(partition));
interested = FALSE;
found = v_partition(c_iterTakeFirst(partitions));
while(found){
if(interested == FALSE){
if(strcmp(v_partitionName(partition),
v_partitionName(found)) == 0){
interested = TRUE;
}
}
c_free(found);
found = v_partition(c_iterTakeFirst(partitions));
}
c_iterFree(partitions);
if(interested == TRUE){
/*
* This means the group is interesting for this
* groupActionStream. Now I have to check if the stream is already
* connected to this group, because we wouldn't want to connect
* multiple times to one single group.
*/
data.connected = FALSE;
data.group = v_group(e->userData);
c_walk(stream->groups, (c_action)isGroupConnected, &data);
if(data.connected == FALSE){
/*
* The stream is not connected to the group yet, so connect now.
*/
v_groupStreamSubscribeGroup(stream, v_group(e->userData));
}
}
v_observerUnlock(v_observer(stream));
}
}
return;
}