inet::StreamRedundancyConfigurator Class Reference

#include <StreamRedundancyConfigurator.h>

Inheritance diagram for inet::StreamRedundancyConfigurator:

Classes
class	Node
	Represents a node in the network. More...
class	Stream
class	StreamDecoding
class	StreamEncoding
class	StreamIdentification
class	StreamMerging
class	StreamNode
class	StreamNodeTreeData
class	StreamSplitting
class	Topology

Public Member Functions
virtual std::vector< std::string >	getStreamNames ()
virtual std::vector< std::vector< std::string > >	getPathFragments (const char *stream)

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	handleParameterChange (const char *name) override
virtual void	computeConfiguration ()
	Computes the network configuration for all nodes in the network. More...
virtual void	clearConfiguration ()
virtual void	computeStreams ()
virtual void	computeStreamSendersAndReceivers (cValueMap *streamConfiguration)
virtual void	computeStreamEncodings (cValueMap *streamConfiguration)
virtual void	computeStreamPolicyConfigurations (cValueMap *streamConfiguration)
virtual void	configureStreams ()
virtual void	configureStreams (Node *node)
Protected Member Functions inherited from inet::NetworkConfiguratorBase
virtual	~NetworkConfiguratorBase ()
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	extractTopology (Topology &topology)
	Extracts network topology by walking through the module hierarchy. More...
virtual std::vector< Node * >	computeShortestNodePath (Node *source, Node *destination) const
virtual std::vector< Link * >	computeShortestLinkPath (Node *source, Node *destination) const
virtual bool	isBridgeNode (Node *node) const
virtual Link *	findLinkIn (const Node *node, const char *neighbor) const
virtual Link *	findLinkOut (const Node *node, const char *neighbor) const
virtual Link *	findLinkOut (const Node *node, const Node *neighbor) const
virtual Link *	findLinkOut (const Interface *interface) const
virtual Topology::Link *	findLinkOut (const Node *node, int gateId) const
virtual Interface *	findInterface (const Node *node, NetworkInterface *networkInterface) const

Protected Attributes
int	minVlanId = -1
int	maxVlanId = -1
cValueArray *	configuration
std::map< std::string, Stream >	streams
std::map< std::pair< std::string, std::string >, int >	nextVlanIds
std::map< std::tuple< std::string, std::string, std::string, std::string >, int >	assignedVlanIds
Protected Attributes inherited from inet::NetworkConfiguratorBase
Topology *	topology = nullptr

Member Function Documentation

clearConfiguration()

void inet::StreamRedundancyConfigurator::clearConfiguration ( )

protectedvirtual

{
    streams.clear();
    nextVlanIds.clear();
    assignedVlanIds.clear();
    if (topology != nullptr)
        topology->clear();
}

Referenced by handleParameterChange().

computeConfiguration()

void inet::StreamRedundancyConfigurator::computeConfiguration ( )

protectedvirtual

Computes the network configuration for all nodes in the network.

The result of the computation is only stored in the configurator.

{
    long initializeStartTime = clock();
    delete topology;
    topology = new Topology();
    TIME(extractTopology(*topology));
    TIME(computeStreams());
    printElapsedTime("initialize", initializeStartTime);
}

Referenced by handleParameterChange(), and initialize().

computeStreamEncodings()

void inet::StreamRedundancyConfigurator::computeStreamEncodings ( cValueMap *  streamConfiguration )

protectedvirtual

{
    int pcp = streamConfiguration->containsKey("pcp") ? streamConfiguration->get("pcp").intValue() : -1;
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        auto networkNode = node->module;
        auto networkNodeName = networkNode->getFullName();
        std::string destinationAddress = streamConfiguration->containsKey("destinationAddress") ? streamConfiguration->get("destinationAddress") : streamConfiguration->get("destination");
        std::string streamName = streamConfiguration->get("name").stringValue();
        // encoding configuration
        auto& stream = streams[streamName];
        auto& streamNode = stream.streamNodes[networkNodeName];
        for (int j = 0; j < streamNode.receivers.size(); j++) {
            auto& receiverNetworkNodeNames = streamNode.receivers[j];
            if (!receiverNetworkNodeNames.empty()) {
                std::string streamNameSuffix;
                for (auto receiverNetworkNodeName : receiverNetworkNodeNames)
                    streamNameSuffix += "_" + receiverNetworkNodeName;
                auto outputStreamName = streamNode.distinctReceivers.size() == 1 ? streamName : streamName + streamNameSuffix;
                auto it = std::find_if(node->streamEncodings.begin(), node->streamEncodings.end(), [&] (const StreamEncoding& streamEncoding) {
                    return streamEncoding.name == outputStreamName;
                });
                if (it != node->streamEncodings.end())
                    continue;
                auto jt = nextVlanIds.emplace(std::pair<std::string, std::string>{networkNodeName, destinationAddress}, 0);
                int vlanId = jt.first->second++;
                if (vlanId > maxVlanId)
                    throw cRuntimeError("Cannot assign VLAN ID in the available range");
                for (int k = 0; k < receiverNetworkNodeNames.size(); k++) {
                    auto receiverNetworkNodeName = receiverNetworkNodeNames[k];
                    EV_DEBUG << "Assigning VLAN id" << EV_FIELD(streamName) << EV_FIELD(networkNodeName) << EV_FIELD(receiverNetworkNodeName) << EV_FIELD(destinationAddress) << EV_FIELD(vlanId) << EV_ENDL;
                    assignedVlanIds[{networkNodeName, receiverNetworkNodeName, destinationAddress, streamName}] = vlanId;
                    StreamEncoding streamEncoding;
                    streamEncoding.name = outputStreamName;
                    streamEncoding.networkInterface = streamNode.interfaces[j][k];
                    streamEncoding.vlanId = vlanId;
                    streamEncoding.pcp = pcp;
                    streamEncoding.destination = destinationAddress;
                    node->streamEncodings.push_back(streamEncoding);
                }
            }
        }
    }
}

Referenced by computeStreams().

computeStreamPolicyConfigurations()

void inet::StreamRedundancyConfigurator::computeStreamPolicyConfigurations ( cValueMap *  streamConfiguration )

protectedvirtual

{
    std::string sourceNetworkNodeName = streamConfiguration->get("source");
    std::string destinationAddress = streamConfiguration->containsKey("destinationAddress") ? streamConfiguration->get("destinationAddress") : streamConfiguration->get("destination");
    std::string streamName = streamConfiguration->get("name").stringValue();
    auto& stream = streams[streamName];
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        auto networkNodeName = node->module->getFullName();
        auto& streamNode = stream.streamNodes[networkNodeName];
        // identification configuration
        if (networkNodeName == sourceNetworkNodeName) {
            StreamIdentification streamIdentification;
            streamIdentification.stream = streamConfiguration->get("name").stringValue();
            streamIdentification.packetFilter = streamConfiguration->containsKey("packetFilter") ? streamConfiguration->get("packetFilter") : cValue("*");
            node->streamIdentifications.push_back(streamIdentification);
        }
        // decoding configuration
        for (auto senderNetworkNodeName : streamNode.senders) {
            auto inputStreamName = streamNode.senders.size() == 1 ? streamName : streamName + "_" + senderNetworkNodeName;
            auto linkIn = findLinkIn(node, senderNetworkNodeName.c_str());
            auto vlanId = assignedVlanIds[{senderNetworkNodeName, networkNodeName, destinationAddress, streamName}];
            StreamDecoding streamDecoding;
            streamDecoding.name = inputStreamName;
            streamDecoding.networkInterface = linkIn->destinationInterface->networkInterface;
            streamDecoding.vlanId = vlanId;
            if (streamDecoding.vlanId > maxVlanId)
                throw cRuntimeError("Cannot assign VLAN ID in the available range");
            node->streamDecodings.push_back(streamDecoding);
        }
        // merging configuration
        if (streamNode.senders.size() > 1) {
            StreamMerging streamMerging;
            streamMerging.outputStream = streamName;
            for (auto senderNetworkNodeName : streamNode.senders) {
                auto inputStreamName = streamName + "_" + senderNetworkNodeName;
                streamMerging.inputStreams.push_back(inputStreamName);
            }
            node->streamMergings.push_back(streamMerging);
        }
        // splitting configuration
        if (streamNode.distinctReceivers.size() != 1) {
            StreamSplitting streamSplitting;
            streamSplitting.inputStream = streamName;
            for (auto& receiverNetworkNodeNames : streamNode.distinctReceivers) {
                std::string streamNameSuffix;
                for (auto receiverNetworkNodeName : receiverNetworkNodeNames)
                    streamNameSuffix += "_" + receiverNetworkNodeName;
                auto outputStreamName = streamName + streamNameSuffix;
                streamSplitting.outputStreams.push_back(outputStreamName);
            }
            node->streamSplittings.push_back(streamSplitting);
        }
    }
}

Referenced by computeStreams().

computeStreams()

void inet::StreamRedundancyConfigurator::computeStreams ( )

protectedvirtual

{
    for (int i = 0; i < configuration->size(); i++) {
        cValueMap *streamConfiguration = check_and_cast<cValueMap *>(configuration->get(i).objectValue());
        computeStreamSendersAndReceivers(streamConfiguration);
        computeStreamEncodings(streamConfiguration);
        computeStreamPolicyConfigurations(streamConfiguration);
    }
}

Referenced by computeConfiguration().

computeStreamSendersAndReceivers()

void inet::StreamRedundancyConfigurator::computeStreamSendersAndReceivers ( cValueMap *  streamConfiguration )

protectedvirtual

{
    std::string streamName = streamConfiguration->get("name").stringValue();
    auto& stream = streams[streamName];
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        auto networkNode = node->module;
        auto networkNodeName = networkNode->getFullName();
        std::string sourceNetworkNodeName = streamConfiguration->get("source");
        cValueArray *trees = check_and_cast<cValueArray *>(streamConfiguration->get("trees").objectValue());
        stream.streamNodes[networkNodeName].senders.resize(trees->size());
        stream.streamNodes[networkNodeName].receivers.resize(trees->size());
        stream.streamNodes[networkNodeName].interfaces.resize(trees->size());
        std::vector<std::string> senderNetworkNodeNames;
        for (int j = 0; j < trees->size(); j++) {
            std::vector<std::string> receiverNetworkNodeNames;
            std::vector<NetworkInterface *> interfaces;
            cValueArray *tree = check_and_cast<cValueArray*>(trees->get(j).objectValue());
            for (int k = 0; k < tree->size(); k++) {
                cValueArray *path = check_and_cast<cValueArray*>(tree->get(k).objectValue());
                for (int l = 0; l < path->size(); l++) {
                    std::string name = path->get(l).stringValue();
                    auto pos = name.find('.');
                    auto nodeName = pos == std::string::npos ? name : name.substr(0, pos);
                    auto interfaceName = pos == std::string::npos ? "" : name.substr(pos + 1);
                    if (nodeName == networkNode->getFullName()) {
                        auto senderName = l != 0 ? path->get(l - 1).stringValue() : nullptr;
                        auto receiverName = l != path->size() - 1 ? path->get(l + 1).stringValue() : nullptr;
                        auto senderNetworkNodeName = senderName != nullptr ? getNodeName(senderName) : "";
                        auto receiverNetworkNodeName = receiverName != nullptr ? getNodeName(receiverName) : "";
                        if (senderName != nullptr && std::find(senderNetworkNodeNames.begin(), senderNetworkNodeNames.end(), senderNetworkNodeName) == senderNetworkNodeNames.end())
                            senderNetworkNodeNames.push_back(senderNetworkNodeName);
                        if (receiverName != nullptr && std::find(receiverNetworkNodeNames.begin(), receiverNetworkNodeNames.end(), receiverNetworkNodeName) == receiverNetworkNodeNames.end()) {
                            Interface *interface = nullptr;
                            if (interfaceName.empty())
                                interface = findLinkOut(node, receiverNetworkNodeName.c_str())->sourceInterface;
                            else
                                interface = *std::find_if(node->interfaces.begin(), node->interfaces.end(), [&] (auto interface) {
                                    return interface->networkInterface->getInterfaceName() == interfaceName;
                                });
                            receiverNetworkNodeNames.push_back(receiverNetworkNodeName);
                            interfaces.push_back(interface->networkInterface);
                        }
                    }
                }
            }
            stream.streamNodes[networkNodeName].receivers[j] = receiverNetworkNodeNames;
            stream.streamNodes[networkNodeName].interfaces[j] = interfaces;
        }
        stream.streamNodes[networkNodeName].senders = senderNetworkNodeNames;
    }
    for (auto& it : stream.streamNodes) {
        auto& streamNode = it.second;
        for (auto& r : streamNode.receivers) {
            if (!r.empty()) {
                if (std::find(streamNode.distinctReceivers.begin(), streamNode.distinctReceivers.end(), r) == streamNode.distinctReceivers.end())
                    streamNode.distinctReceivers.push_back(r);
            }
        }
    }
    EV_DEBUG << "Stream " << streamName << std::endl;
    for (auto& it : stream.streamNodes) {
        EV_DEBUG << "  Node " << it.first << std::endl;
        auto& streamNode = it.second;
        for (int i = 0; i < streamNode.senders.size(); i++) {
            auto& e = streamNode.senders[i];
            EV_DEBUG << "    Sender for tree " << i << " = " << e << std::endl;
        }
        for (int i = 0; i < streamNode.receivers.size(); i++) {
            auto& receiverNodes = streamNode.receivers[i];
            EV_DEBUG << "    Receivers for tree " << i << " = [";
            for (int j = 0; j < receiverNodes.size(); j++) {
                auto& e = receiverNodes[j];
                if (j != 0)
                    EV_DEBUG << ", ";
                EV_DEBUG << e;
            }
            EV_DEBUG << "]" << std::endl;
        }
    }
}

Referenced by computeStreams().

configureStreams() [1/2]

void inet::StreamRedundancyConfigurator::configureStreams ( )

protectedvirtual

{
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        configureStreams(node);
    }
}

Referenced by handleParameterChange(), and initialize().

configureStreams() [2/2]

void inet::StreamRedundancyConfigurator::configureStreams ( Node *  node )

protectedvirtual

{
    auto networkNode = node->module;
    auto macForwardingTable = networkNode->findModuleByPath(".macTable");
    auto ieee8021qTagHeaderChecker = networkNode->findModuleByPath(".ieee8021q.qTagHeaderChecker");
    auto streamRelay = networkNode->findModuleByPath(".bridging.streamRelay");
    if (streamRelay == nullptr)
        streamRelay = networkNode->findModuleByPath(".ieee8021r.policy.streamRelay");
    auto streamIdentifierLayer = networkNode->findModuleByPath(".bridging.streamIdentifier");
    if (streamIdentifierLayer == nullptr)
        streamIdentifierLayer = networkNode->findModuleByPath(".ieee8021r.policy.streamIdentifier");
    auto streamIdentifier = streamIdentifierLayer != nullptr ? streamIdentifierLayer->getSubmodule("identifier") : streamIdentifierLayer;
    auto streamMerger = streamRelay != nullptr ? streamRelay->getSubmodule("merger") : nullptr;
    auto streamSplitter = streamRelay != nullptr ? streamRelay->getSubmodule("splitter") : streamRelay;
    auto streamCoder = networkNode->findModuleByPath(".bridging.streamCoder");
    if (streamCoder == nullptr)
        streamCoder = networkNode->findModuleByPath(".ieee8021r.policy.streamCoder");
    auto streamDecoder = streamCoder != nullptr ? streamCoder->getSubmodule("decoder") : nullptr;
    auto streamEncoder = streamCoder != nullptr ? streamCoder->getSubmodule("encoder") : nullptr;
    if (streamIdentifier != nullptr && !node->streamIdentifications.empty()) {
        cValueArray *parameterValue = new cValueArray();
        for (auto& streamIdentification : node->streamIdentifications) {
            cValueMap *value = new cValueMap();
            value->set("packetFilter", streamIdentification.packetFilter);
            value->set("stream", streamIdentification.stream);
            value->set("sequenceNumbering", cValue(true));
            parameterValue->add(value);
        }
        EV_INFO << "Configuring stream merging" << EV_FIELD(networkNode) << EV_FIELD(streamIdentifier) << EV_FIELD(parameterValue) << EV_ENDL;
        streamIdentifier->par("mapping") = parameterValue;
    }
    if (streamDecoder != nullptr && !node->streamDecodings.empty()) {
        cValueArray *parameterValue = new cValueArray();
        for (auto& streamDecoding : node->streamDecodings) {
            cValueMap *value = new cValueMap();
            value->set("interface", streamDecoding.networkInterface->getInterfaceName());
            value->set("vlan", streamDecoding.vlanId);
            value->set("stream", streamDecoding.name.c_str());
            parameterValue->add(value);
        }
        EV_INFO << "Configuring stream decoding" << EV_FIELD(networkNode) << EV_FIELD(streamDecoder) << EV_FIELD(parameterValue) << EV_ENDL;
        streamDecoder->par("mapping") = parameterValue;
    }
    if (streamMerger != nullptr && !node->streamMergings.empty()) {
        cValueMap *parameterValue = new cValueMap();
        for (auto& streamMerging : node->streamMergings) {
            for (auto inputStream : streamMerging.inputStreams)
                parameterValue->set(inputStream.c_str(), streamMerging.outputStream.c_str());
        }
        EV_INFO << "Configuring stream merging" << EV_FIELD(networkNode) << EV_FIELD(streamMerger) << EV_FIELD(parameterValue) << EV_ENDL;
        streamMerger->par("mapping") = parameterValue;
    }
    if (streamSplitter != nullptr && !node->streamSplittings.empty()) {
        cValueMap *parameterValue = new cValueMap();
        for (auto& streamSplitting : node->streamSplittings) {
            cValueArray *value = new cValueArray();
            for (auto outputStream : streamSplitting.outputStreams)
                value->add(outputStream.c_str());
            parameterValue->set(streamSplitting.inputStream.c_str(), value);
        }
        EV_INFO << "Configuring stream splitting" << EV_FIELD(networkNode) << EV_FIELD(streamSplitter) << EV_FIELD(parameterValue) << EV_ENDL;
        streamSplitter->par("mapping") = parameterValue;
    }
    if (streamEncoder != nullptr && !node->streamEncodings.empty()) {
        cValueArray *parameterValue = new cValueArray();
        std::map<std::string, std::pair<int, int>> mapping;
        for (auto& streamEncoding : node->streamEncodings) {
            auto it = mapping.find(streamEncoding.name);
            if (it != mapping.end()) {
                if (it->second.first != streamEncoding.vlanId)
                    throw cRuntimeError("Invalid state");
            }
            else
                mapping[streamEncoding.name] = {streamEncoding.vlanId, streamEncoding.pcp};
        }
        for (auto& it : mapping) {
            cValueMap *value = new cValueMap();
            value->set("stream", it.first);
            value->set("vlan", it.second.first);
            value->set("pcp", it.second.second);
            parameterValue->add(value);
        }
        EV_INFO << "Configuring stream encoding" << EV_FIELD(networkNode) << EV_FIELD(streamEncoder) << EV_FIELD(parameterValue) << EV_ENDL;
        streamEncoder->par("mapping") = parameterValue;
    }
    if (macForwardingTable != nullptr && !node->streamEncodings.empty()) {
        cValueArray *parameterValue = new cValueArray();
        for (auto& streamEncoding : node->streamEncodings) {
            cValueMap *value = new cValueMap();
            value->set("address", streamEncoding.destination.c_str());
            value->set("vlan", streamEncoding.vlanId);
            value->set("interface", streamEncoding.networkInterface->getInterfaceName());
            parameterValue->add(value);
        }
        EV_INFO << "Configuring MAC address table" << EV_FIELD(networkNode) << EV_FIELD(macForwardingTable) << EV_FIELD(parameterValue) << EV_ENDL;
        macForwardingTable->par("forwardingTable") = parameterValue;
    }
    if (ieee8021qTagHeaderChecker != nullptr) {
        std::set<int> vlanIds;
        for (auto& streamDecoding : node->streamDecodings)
            vlanIds.insert(streamDecoding.vlanId);
        cValueArray *parameterValue = new cValueArray();
        for (int vlanId : vlanIds)
            parameterValue->add(vlanId);
        EV_INFO << "Configuring VLAN filter" << EV_FIELD(networkNode) << EV_FIELD(ieee8021qTagHeaderChecker) << EV_FIELD(parameterValue) << EV_ENDL;
        ieee8021qTagHeaderChecker->par("vlanIdFilter") = parameterValue;
    }
}

getPathFragments()

std::vector< std::vector< std::string > > inet::StreamRedundancyConfigurator::getPathFragments ( const char *  stream )

virtual

{
    for (int i = 0; i < configuration->size(); i++) {
        cValueMap *streamConfiguration = check_and_cast<cValueMap *>(configuration->get(i).objectValue());
        if (!strcmp(streamConfiguration->get("name").stringValue(), stream)) {
            std::vector<std::vector<std::string>> memberStreams;
            std::string streamName = streamConfiguration->get("name").stringValue();
            cValueArray *trees = check_and_cast<cValueArray *>(streamConfiguration->get("trees").objectValue());
            for (int j = 0; j < trees->size(); j++) {
                cValueArray *tree = check_and_cast<cValueArray*>(trees->get(j).objectValue());
                for (int k = 0; k < tree->size(); k++) {
                    cValueArray *path = check_and_cast<cValueArray*>(tree->get(k).objectValue());
                    std::vector<std::string> memberStream;
                    for (int l = 0; l < path->size(); l++) {
                        std::string name = path->get(l).stringValue();
                        auto pos = name.find('.');
                        auto nodeName = pos == std::string::npos ? name : name.substr(0, pos);
                        auto module = findModuleByPath(nodeName.c_str());
                        Node *node = (Node *)topology->getNodeFor(module);
                        bool isMerging = false;
                        for (auto streamMerging : node->streamMergings)
                            if (streamMerging.outputStream == streamName)
                                isMerging = true;
                        bool isSplitting = false;
                        for (auto streamSplitting : node->streamSplittings)
                            if (streamSplitting.inputStream == streamName)
                                isSplitting = true;
                        memberStream.push_back(name);
                        if (isMerging || isSplitting) {
                            if (memberStream.size() > 1 && std::find(memberStreams.begin(), memberStreams.end(), memberStream) == memberStreams.end())
                                memberStreams.push_back(memberStream);
                            memberStream.clear();
                            memberStream.push_back(name);
                        }
                    }
                    if (memberStream.size() > 1 && std::find(memberStreams.begin(), memberStreams.end(), memberStream) == memberStreams.end())
                        memberStreams.push_back(memberStream);
                }
            }
            return memberStreams;
        }
    }
    throw cRuntimeError("Stream not found");
}

getStreamNames()

std::vector< std::string > inet::StreamRedundancyConfigurator::getStreamNames ( )

virtual

{
    std::vector<std::string> result;
    for (auto& it : streams)
        result.push_back(it.first);
    return result;
}

handleParameterChange()

void inet::StreamRedundancyConfigurator::handleParameterChange ( const char *  name )

overrideprotectedvirtual

{
    if (name != nullptr) {
        if (!strcmp(name, "configuration")) {
            configuration = check_and_cast<cValueArray *>(par("configuration").objectValue());
            clearConfiguration();
            computeConfiguration();
            configureStreams();
        }
    }
}

initialize()

void inet::StreamRedundancyConfigurator::initialize ( int  stage )

overrideprotectedvirtual

{
    NetworkConfiguratorBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        minVlanId = par("minVlanId");
        maxVlanId = par("maxVlanId");
        configuration = check_and_cast<cValueArray *>(par("configuration").objectValue());
    }
    else if (stage == INITSTAGE_NETWORK_CONFIGURATION) {
        computeConfiguration();
        configureStreams();
    }
}

Member Data Documentation

assignedVlanIds

std::map<std::tuple<std::string, std::string, std::string, std::string>, int> inet::StreamRedundancyConfigurator::assignedVlanIds

protected

Referenced by clearConfiguration(), computeStreamEncodings(), and computeStreamPolicyConfigurations().

configuration

cValueArray* inet::StreamRedundancyConfigurator::configuration

protected

Referenced by computeStreams(), getPathFragments(), handleParameterChange(), and initialize().

maxVlanId

int inet::StreamRedundancyConfigurator::maxVlanId = -1

protected

Referenced by computeStreamEncodings(), computeStreamPolicyConfigurations(), and initialize().

minVlanId

int inet::StreamRedundancyConfigurator::minVlanId = -1

protected

Referenced by initialize().

nextVlanIds

std::map<std::pair<std::string, std::string>, int> inet::StreamRedundancyConfigurator::nextVlanIds

protected

Referenced by clearConfiguration(), and computeStreamEncodings().

streams

std::map<std::string, Stream> inet::StreamRedundancyConfigurator::streams

protected

Referenced by clearConfiguration(), computeStreamEncodings(), computeStreamPolicyConfigurations(), computeStreamSendersAndReceivers(), and getStreamNames().

---

The documentation for this class was generated from the following files:

• StreamRedundancyConfigurator.h
• StreamRedundancyConfigurator.cc