networkMapCentralNode.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2016 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include "networkMapNode.h"
#include <vlutil/vlString.h>
#include <iterator>
#include <vector>

class DtNetworkMapCentralNode
{
public:

   DtNetworkMapCentralNode();

   virtual ~DtNetworkMapCentralNode();

   DtNetworkMapNode* addNode( int fedId,
      const MAKRti::DtString& federationName,
      const MAKRti::DtString& processName, const MAKRti::DtString &fedType,
      const MAKRti::DtString& fedName, float rad );

   DtNetworkMapNode* addExecNode( int id, const MAKRti::DtString & name, float rad );

   DtNetworkMapNode* addForwarderNode( int id, const MAKRti::DtString & name,
      int port, float rad );

   void removeForwarderNode(const MAKRti::DtString & name, int port);

   void update( float delta );

   void shutdown();

   bool searchNodes( int  fedId, const MAKRti::DtString & federationName,
      int & resultIndex );

   void updateFederatePositions();

   void updateForwarderPositions();

   void setCentraLightweightlNode( const MAKRti::DtString& name,
      const MAKRti::DtString& displayName,
      int id, float radius );

   void setCentralForwarderNode( const MAKRti::DtString& name,
      int port,
      const MAKRti::DtString& displayName,
      int id, float radius );

private:

   void updatePositions( std::vector<DtNetworkMapNode *> & myNodes,
      bool areForwarders = false );

public:

   DtNetworkMapNode * getNode(unsigned int  index);

   DtNetworkMapNode * getNodeByFederateHandle( unsigned int fedHandle,
      const MAKRti::DtString & federationName );

   DtNetworkMapNode * getNodeByFederateName( const MAKRti::DtString & fedName,
      const MAKRti::DtString & federationName );

   DtNetworkMapNode * getForwarderNode( unsigned int  index );

   DtNetworkMapNode * getForwarderNodeByName( const MAKRti::DtString& forwarderName, int port );

   int removeNode( unsigned int  fedHandle, const MAKRti::DtString & federationName );

   void clearList();

   void clearTouchedNodes();

   void searchForDeadNodes();

   inline bool drawLines() { return myShouldDrawLines; }

   inline bool drawText() { return myShouldDrawText; }

   inline unsigned int getSize() { return myNodes.size(); }
   inline unsigned int getFwdSize() { return myForwarderNodes.size(); }

   inline const std::vector<DtNetworkMapNode*> getNodes() { return myNodes; }

   inline MAKRti::DtString getCentralNodeName() { return myName; }

   inline int getPort() { return myPort; }

   inline bool isLightweight() { return myIsLightweight; }

   inline bool hasRtiExec() { return myHasExec; }

   inline void setHasExec( bool hasAnExec ) { myHasExec = hasAnExec; }

   bool hasCentralForwarder() const;

protected:

   inline void setIsLightweight( bool isLw ) { myIsLightweight = isLw; }

   void setCentralNodeName( const MAKRti::DtString & string ) { myName = string; }

   void setCentralNodePort(int port) { myPort = port; }

   _vec2 calcFederateDestination(int max_federates, int federate_no );

protected:

   bool myHasExec;                                // has an rtiExec
   bool myIsLightweight;                          // this is a lightweight connection
   bool myShouldDrawLines;                        // should we draw the lines?
   bool myShouldDrawText;                         // should we draw the id text?
   bool myHasDoneShutdown;                        // has done a shutdown on ourselves
   float myRadius;                                // the radius of this node and its children
   MAKRti::DtString myName;                       // our central node name
   int myPort;                                    // our central node port
   std::vector<DtNetworkMapNode *> myNodes;           // our nodes
   std::vector<DtNetworkMapNode *> myForwarderNodes;  // Peer forwarders

};