#include <GateScheduleConfiguratorBase.h>

Classes
class	Application

class	Device

class	Flow

class	NetworkNode

class	PathFragment

class	Port

class	Switch

Public Member Functions
	~Input ()

Device *	findDevice (cModule *module)

Device *	getDevice (cModule *module)

Port *	findPort (cModule *module)

Port *	getPort (cModule *module)

NetworkNode *	findNetworkNode (cModule *module)

NetworkNode *	getNetworkNode (cModule *module)

Public Attributes
std::vector< Device * >	devices

std::vector< Application * >	applications

std::vector< Port * >	ports

std::vector< Switch * >	switches

std::vector< Flow * >	flows

std::vector< NetworkNode * >	networkNodes

Constructor & Destructor Documentation

◆ ~Input()

inet::GateScheduleConfiguratorBase::Input::~Input ( )

inline

                  {
             for (auto device : devices) delete device;
             for (auto application : applications) delete application;
             for (auto port : ports) delete port;
             for (auto switch_ : switches) delete switch_;
             for (auto flow : flows) delete flow;
         }

Member Function Documentation

◆ findDevice()

Device* inet::GateScheduleConfiguratorBase::Input::findDevice ( cModule * module )

inline

                                             {
             auto it = std::find_if(devices.begin(), devices.end(), [&] (const Device *device) {
                return device->module == module;
             });
             return it != devices.end() ? *it : nullptr;
         }

◆ findNetworkNode()

NetworkNode* inet::GateScheduleConfiguratorBase::Input::findNetworkNode ( cModule * module )

inline

                                                       {
             auto it = std::find_if(networkNodes.begin(), networkNodes.end(), [&] (const NetworkNode *networkNode) {
                return networkNode->module == module;
             });
             return it != networkNodes.end() ? *it : nullptr;
         }

◆ findPort()

Port* inet::GateScheduleConfiguratorBase::Input::findPort ( cModule * module )

inline

                                         {
             auto it = std::find_if(ports.begin(), ports.end(), [&] (const Port *port) {
                return port->module == module;
             });
             return it != ports.end() ? *it : nullptr;
         }

◆ getDevice()

Device* inet::GateScheduleConfiguratorBase::Input::getDevice ( cModule * module )

inline

                                            {
             auto device = findDevice(module);
             if (device == nullptr)
                 throw cRuntimeError("Cannot find device");
             else
                 return device;
         }

Referenced by inet::GateScheduleConfiguratorBase::addFlows().

◆ getNetworkNode()

NetworkNode* inet::GateScheduleConfiguratorBase::Input::getNetworkNode ( cModule * module )

inline

                                                      {
             auto networkNode = findNetworkNode(module);
             if (networkNode == nullptr)
                 throw cRuntimeError("Cannot find network node");
             else
                 return networkNode;
         }

Referenced by inet::GateScheduleConfiguratorBase::addPorts().

◆ getPort()

Port* inet::GateScheduleConfiguratorBase::Input::getPort ( cModule * module )

inline

                                        {
             auto port = findPort(module);
             if (port == nullptr)
                 throw cRuntimeError("Cannot find port");
             else
                 return port;
         }