MKNode.h

#ifndef MKNODE_H
#define MKNODE_H

#include <vector>
#include <sys/types.h>
#include <map>

#include "include/commmodel.hpp"
#include "MKPacket.h"
#include "MKLib.h"

class MKNode {
public:
        
        friend class MKNodeTests;
        
        MKNode(mac_t mac_addr, ip4_t ip_addr);
        ~MKNode();

        struct MKNeighbor {

                MKNeighbor(const MKNode *node);
                ~MKNeighbor();

                const MKNode *node;

                latency_t                       latency;

                signal_strength_t       signal;

                weight_t                        weight;

                throughput_t            throughput;

                inactive_t                      inactive;
        };

        struct MKRoute {

                MKRoute(const MKNode *dest);
                ~MKRoute();

                const MKNode *node;

                latency_t latency;

                void clearHops();
                void addNextHop(MKNode *);
                inline std::vector<MKNode *> getHops() { return std::vector<MKNode *>(hops); }
                int length() { return hops.size(); }
                throughput_t throughput();

        private:
                std::vector<MKNode *> hops;
        };
        
        operator std::string() const;

        node *asCommNode() const;

        void addNeighbor(const MKNode *node, NeighborInfo *link);

        MKNeighbor *nbr(mac_t target);

        MKRoute *route(mac_t target);

        MKRoute *addRoute(MKNode *target);

        void clearRoutes();

        void clearNeighbors();

        inline ip4_t getIP4() const { return ip4; }

        inline mac_t getMAC() const { return mac; }

        std::vector<const MKNode *> getNeighbors() const;

        inline void setIP(ip4_t ip) { ip4 = ip; }
        
protected:
        
        const mac_t mac;
        
        ip4_t ip4;
        std::map<MacAddr, MKNeighbor *> neighbors;
        std::map<MacAddr, MKRoute *> routes;

};

#endif