inet::visualizer::LineManager Class Reference

#include <LineManager.h>

Classes
class	CacheEntry
class	ModuleLine
class	ModulePath

Public Member Functions
void	addModuleLine (const ModuleLine *moduleLine)
void	removeModuleLine (const ModuleLine *moduleLine)
void	addModulePath (const ModulePath *modulePath)
void	removeModulePath (const ModulePath *modulePath)
Coord	getLineShift (int sourceModuleId, int destinationModuleId, const Coord &sourcePosition, const Coord &destinationPosition, const char *shiftMode, int shiftOffset)

Static Public Member Functions
static LineManager *	getLineManager (const cCanvas *canvas)

Protected Member Functions
std::pair< int, int >	getKey (int fromModuleId, int toModuleId)
void	updateOffsets (int fromModuleId, int toModuleId)
void	updateOffsets (const ModuleLine *moduleLine)
void	updateOffsets (const ModulePath *modulePath)

Static Protected Member Functions
static bool	compareModuleLines (const ModuleLine *moduleLine1, const ModuleLine *moduleLine2)
static bool	compareModulePaths (std::pair< const ModulePath *, int > element1, std::pair< const ModulePath *, int > element2)

Protected Attributes
std::map< std::pair< int, int >, CacheEntry >	cacheEntries

Static Protected Attributes
static std::map< const cCanvas *, LineManager >	lineManagers

Member Function Documentation

void inet::visualizer::LineManager::addModuleLine

(

const ModuleLine *

moduleLine

)

Referenced by inet::visualizer::LinkCanvasVisualizerBase::addLinkVisualization(), and inet::visualizer::RoutingTableCanvasVisualizer::addRouteVisualization().

{
    auto key = getKey(moduleLine->sourceModuleId, moduleLine->destinationModuleId);
    auto& cacheEntry = cacheEntries[key];
    cacheEntry.moduleLines.push_back(moduleLine);
    updateOffsets(moduleLine);
}

void inet::visualizer::LineManager::addModulePath

(

const ModulePath *

modulePath

)

Referenced by inet::visualizer::PathCanvasVisualizerBase::addPathVisualization().

{
    for (int index = 1; index < modulePath->moduleIds.size(); index++) {
        auto key = getKey(modulePath->moduleIds[index - 1], modulePath->moduleIds[index]);
        auto value = std::pair<const ModulePath *, int>(modulePath, index - 1);
        auto& cacheEntry = cacheEntries[key];
        cacheEntry.modulePaths.push_back(value);
    }
    updateOffsets(modulePath);
}

bool inet::visualizer::LineManager::compareModuleLines ( const ModuleLine *  moduleLine1, const ModuleLine *  moduleLine2  )

staticprotected

Referenced by updateOffsets().

{
    auto v1 = moduleLine1->sourceModuleId < moduleLine1->destinationModuleId ? moduleLine1->shiftPriority : moduleLine1->shiftPriority;
    auto v2 = moduleLine2->sourceModuleId < moduleLine2->destinationModuleId ? moduleLine2->shiftPriority : -moduleLine2->shiftPriority;
    return v1 < v2;
}

bool inet::visualizer::LineManager::compareModulePaths ( std::pair< const ModulePath *, int >  element1, std::pair< const ModulePath *, int >  element2  )

staticprotected

Referenced by updateOffsets().

{
    auto v1 = element1.first->moduleIds[element1.second] < element1.first->moduleIds[element1.second + 1] ? element1.first->shiftPriority : -element1.first->shiftPriority;
    auto v2 = element2.first->moduleIds[element2.second] < element2.first->moduleIds[element2.second + 1] ? element2.first->shiftPriority : -element2.first->shiftPriority;
    return v1 < v2;
}

std::pair<int, int> inet::visualizer::LineManager::getKey ( int  fromModuleId, int  toModuleId  )

inlineprotected

Referenced by addModuleLine(), addModulePath(), getLineShift(), removeModuleLine(), removeModulePath(), and updateOffsets().

                                                               {
        return fromModuleId < toModuleId ? std::pair<int, int>(fromModuleId, toModuleId) : std::pair<int, int>(toModuleId, fromModuleId);
    }

LineManager * inet::visualizer::LineManager::getLineManager ( const cCanvas *  canvas )

static

Referenced by inet::visualizer::RoutingTableVisualizerBase::initialize(), inet::visualizer::LinkVisualizerBase::initialize(), and inet::visualizer::PathVisualizerBase::initialize().

{
    return &lineManagers[canvas];
}

Coord inet::visualizer::LineManager::getLineShift	(	int	sourceModuleId,
		int	destinationModuleId,
		const Coord &	sourcePosition,
		const Coord &	destinationPosition,
		const char *	shiftMode,
		int	shiftOffset
	)

Referenced by inet::visualizer::LinkCanvasVisualizerBase::refreshDisplay(), inet::visualizer::RoutingTableCanvasVisualizer::refreshDisplay(), and inet::visualizer::PathCanvasVisualizerBase::refreshDisplay().

{
    auto sign = *shiftMode;
    if (sign == '+' || sign == '-')
        shiftMode++;
    Coord shift;
    if (!strcmp("none", shiftMode))
        return Coord::ZERO;
    else if (!strcmp("normal", shiftMode)) {
        auto direction = sourceModuleId < destinationModuleId ? destinationPosition - sourcePosition : sourcePosition - destinationPosition;
        direction.normalize();
        shift = Coord(-direction.y, direction.x, 0);
    }
    else if (!strcmp("x", shiftMode))
        shift = Coord::X_AXIS;
    else if (!strcmp("y", shiftMode))
        shift = Coord::Y_AXIS;
    else if (!strcmp("z", shiftMode))
        shift = Coord::Z_AXIS;
    else
        throw cRuntimeError("Unknown shift mode: %s", shiftMode);
    if (sign == '+')
        shift *= shiftOffset;
    else if (sign == '-')
        shift *= -shiftOffset;
    else {
        auto& cacheEntry = cacheEntries[getKey(sourceModuleId, destinationModuleId)];
        auto count = cacheEntry.moduleLines.size() + cacheEntry.modulePaths.size();
        shift *= (double)shiftOffset - ((double)count - 1) / 2;
    }
    return shift;
}

void inet::visualizer::LineManager::removeModuleLine

(

const ModuleLine *

moduleLine

)

Referenced by inet::visualizer::LinkCanvasVisualizerBase::removeLinkVisualization(), and inet::visualizer::RoutingTableCanvasVisualizer::removeRouteVisualization().

{
    auto key = getKey(moduleLine->sourceModuleId, moduleLine->destinationModuleId);
    auto& cacheEntry = cacheEntries[key];
    cacheEntry.moduleLines.erase(std::remove(cacheEntry.moduleLines.begin(), cacheEntry.moduleLines.end(), moduleLine), cacheEntry.moduleLines.end());
    updateOffsets(moduleLine);
}

void inet::visualizer::LineManager::removeModulePath

(

const ModulePath *

modulePath

)

Referenced by inet::visualizer::PathCanvasVisualizerBase::removePathVisualization().

{
    for (int index = 1; index < modulePath->moduleIds.size(); index++) {
        auto key = getKey(modulePath->moduleIds[index - 1], modulePath->moduleIds[index]);
        auto value = std::pair<const ModulePath *, int>(modulePath, index - 1);
        auto& cacheEntry = cacheEntries[key];
        cacheEntry.modulePaths.erase(std::remove(cacheEntry.modulePaths.begin(), cacheEntry.modulePaths.end(), value), cacheEntry.modulePaths.end());
    }
    updateOffsets(modulePath);
}

void inet::visualizer::LineManager::updateOffsets ( int  fromModuleId, int  toModuleId  )

protected

Referenced by addModuleLine(), addModulePath(), removeModuleLine(), removeModulePath(), and updateOffsets().

{
    auto key = getKey(fromModuleId, toModuleId);
    auto& cacheEntry = cacheEntries[key];
    std::sort(cacheEntry.moduleLines.begin(), cacheEntry.moduleLines.end(), compareModuleLines);
    std::sort(cacheEntry.modulePaths.begin(), cacheEntry.modulePaths.end(), compareModulePaths);
    int shiftOffset = 0;
    for (auto& moduleLine : cacheEntry.moduleLines)
        moduleLine->shiftOffset = shiftOffset++;
    for (auto& element : cacheEntry.modulePaths)
        element.first->shiftOffsets[element.second] = shiftOffset++;
}

void inet::visualizer::LineManager::updateOffsets ( const ModuleLine *  moduleLine )

protected

{
    updateOffsets(moduleLine->sourceModuleId, moduleLine->destinationModuleId);
}

void inet::visualizer::LineManager::updateOffsets ( const ModulePath *  modulePath )

protected

{
    for (int index = 1; index < modulePath->moduleIds.size(); index++)
        updateOffsets(modulePath->moduleIds[index - 1], modulePath->moduleIds[index]);
}

Member Data Documentation

std::map<std::pair<int, int>, CacheEntry> inet::visualizer::LineManager::cacheEntries

protected

Referenced by addModuleLine(), addModulePath(), getLineShift(), removeModuleLine(), removeModulePath(), and updateOffsets().

std::map< const cCanvas *, LineManager > inet::visualizer::LineManager::lineManagers

staticprotected

Referenced by getLineManager().

---

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

• LineManager.h
• LineManager.cc