MKCommModel.h

#ifndef MKCOMMMODEL_H
#define MKCOMMMODEL_H

#include <semaphore.h>

#include <vector>
#include <stdint.h>
#include <map>

#include "include/bson/bson.h"

#include "include/commmodel.hpp"
#include "MKConfig.h"
#include "MKLib.h"
#include "MKNode.h"
#include "MKPacket.h"
#include "HeartBeatListener.h"
#include "MKControl.h"

class MKCommModel : public CommModel {
public:

        friend class HeartBeatListenerTests;
        friend class MKControlTests;
        friend class MKCommModelTests;

    MKCommModel();
    ~MKCommModel();
        
        virtual node* get_node(mac_t tar_mac_addr);

        virtual node* get_node(ip4_t tar_ip_addr);

        virtual throughput_t get_throughput(node* n1, node* n2);

        virtual latency_t get_latency(node* n1, node* n2);

        virtual signal_strength_t get_signal_strength(node* n1, node* n2);

        virtual weight_t get_weight(node* n1, node* n2);

        virtual inactive_t get_inactive_time(node *n1, node *n2);

        virtual std::vector<node *> get_all_nodes();
                
        virtual std::vector<node *> get_neighbors(node*);

        virtual bool set_target(node*);

        virtual bool set_ocu_machine(node*);

        virtual std::vector<node *> get_preferred_path();

        virtual int size();

    void update(HeartBeatPacket *packet);

        void update(mongo::BSONObj *, MKRequest *req);

        static std::ostream &log() { return *logh; }

private:

        struct MKCommModelInit { MKCommModelInit() { MKCommModel::staticInit(); } };
        static MKCommModelInit init;
        static void staticInit();

        MKNode *find(mac_t addr);
        MKNode *find(node* node);

        MKNode *findByIP(ip4_t addr);

        node *ocu, *target;

        int count;
        std::map<MacAddr, MKNode *> *nodes;

        sem_t sem1;
        
        std::map<ip4_t, mac_t> *ipTable;
        
        pthread_t heartBeatThread;

        MKControl *control; 

        static std::ostream *logh;
};

#endif