CommModule.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------





#ifndef __COMM_MODULE_H_
#define __COMM_MODULE_H_

#ifdef MIP_HOST_APPLE

#include <applePatch.h>
#endif

#include <stdlib.h>
#include <assert.h>
#include <string>
#include <list>
#include <sstream>
#include <vector>
#include <utility>
#include <map>

#include <baselib.h>
#include <Resource.h>
#include <Serialization.h>

using namespace MipBaselib;

namespace MipResources{
 /* @{ */


class CommNode{
 private:
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & _ids;
   ar & _tasks;
   ar & _taskNames;
  }
  
  vector<int> _ids;
  vector<int> _tasks;
  vector<string> _taskNames;
  
  /*static constants*/
  static const int IDS_RESERV_SIZE = 10; 
  static const int TASKS_RESERV_SIZE = 10; 
  
  
  
 public:
  CommNode();
  
  CommNode(int id);
  
  CommNode(int id, int task);
  
  CommNode(int id, string taskname);
  
  CommNode(const CommNode& n);
  
  CommNode& operator=(const CommNode& n);
  
  bool addId(const int id); 
  
  bool addTask(const int task);
  
  bool addTaskName(const string taskname);
  
  bool deleteId(const int id);
 
  bool deleteTask(const int task);
  
  bool deleteTaskName(const string taskname);
  
  vector<int> ids();
  
  vector<int> tasks();
  
  vector<string> taskNames();
  
  int getId(int i);
  
  int getIdsSize();
  
  int getTask(int i);
  
  int getTasksSize();
  
  string getTaskNames(int i);
  
  int getTaskNamesSize();
  
  string print();
};



class CommPacket{ 
 private:
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & _message;
   ar & _messageType;
   ar & _sender;
   ar & _recipient;
   ar & _time;
  }
  
  string _message;
  string _messageType;
  CommNode _sender;
  CommNode _recipient;
  Time _time;
  
 public:
  CommPacket();
  
  CommPacket(string message, string messageType, CommNode sender, CommNode recipient);
  
  CommPacket(const CommPacket& p);
  
  CommPacket& operator=(const CommPacket& p);
  
  bool deleteRecipientId(const int id);
  
  bool deleteRecipientTask(const int task);
  
  string message();
  
  string messageType();
  
  CommNode sender();
  
  CommNode recipient();
  
  Time time();
  
  void setSender(const CommNode& sender);
  
  void setRecipient(const CommNode& recipient);
  
  string print();
};


class CommModulePar{
 private:
 protected:
 public:
  CommModulePar ();
  
  CommModulePar(const CommModulePar &p);
  
  CommModulePar& operator=(const CommModulePar& p);
};


typedef vector<CommPacket*> CommBox;


typedef pair<string,CommNode> CommStoredPacketString;



class CommModuleVar{ 
 private:
  
  /*static constants*/
  static const int PACKETS_RESERV_SIZE = 100; /* TODO eliminate the PACKETS_RESERV_SIZE */
  
 protected:

 public:
  
  
//   vector<CommPacket> storedPackets;
  list<CommPacket> storedPackets;
  
  pthread_mutex_t rcvMutex;
  map<int,CommBox> boxes;
  map<int,CommBox>::iterator boxesIt;
  
  vector<string> assignedBoxes;
  
  CommModuleVar ();
  
  CommModuleVar(const CommModuleVar &v);
  
  CommModuleVar& operator=(const CommModuleVar& v);

  string print();
};


class CommModule : public Resource{
 
 private:
 
  bool isBox(int task);
  
  bool isBox(string taskName, int& boxNumber);
  
  void updateBoxes();
  
  void flush();

  bool storePacket(CommPacket packet);
  
 protected:
  
  CommModulePar *_par;
  
  CommModuleVar *_var;
  bool on;
  
 public:
  
  CommModule(){
   on = false;
   _var = new CommModuleVar();
   _par = new CommModulePar();
  };

  bool storePacketString(string& packetString);
  
  void requestBox(int task);
  
  int requestBox(string taskName);
  
  bool receive(int task, CommBox & packets);
  
  void receiveAck(int task, CommBox & packets);
    
  void send(CommPacket packet);

  virtual bool sendPacketString(string& packetString, CommNode recipient)=0;

  string print();
  
};


 /* @} */
 
};// end namespace MipResources{


#endif