PursuingComm.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 __PURSUING_COMM_H_
#define __PURSUING_COMM_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <fstream>

#include <Task.h>
#include <Resource.h>
#include <SharedMem.h>
#include <Time.h>

#include <CommonOptions.h>
#include <CommModule.h>
#include <PursuingData.h>

using namespace MipResources;

namespace MipTasks{
 
 /* @{ */
 
 enum PursuingMessageTypes{
 PUR_MES_MY_POSE, 
 PUR_MES_MY_STATE,
 PUR_MES_GIMME_FRONTIER, 
 PUR_MES_MY_FRONTIER, 
 PUR_MES_NO_GUARD_FRONTIER, 
 PUR_MES_YOUR_NEW_FRONTIER, 
 PUR_MES_FOLLOW, 
 PUR_MES_EXPAND, 
 PUR_MES_WANDER, 
 PUR_MES_WANNA_BE_FOLLOWER, 
 PUR_MES_NO_GUARD_AFFILIATION, 
 PUR_MES_FOLLOW_ME, 
 PUR_MES_NUM 
 };
 
 static const char* pursuingMessageStrings[PUR_MES_NUM] = {
 "MY_POSE",
 "MY_STATE",
 "GIMME_FRONTIER",
 "MY_FRONTIER",
 "NO_GUARD_FRONTIER",
 "YOUR_NEW_FRONTIER",
 "FOLLOW",
 "EXPAND",
 "WANDER",
 "WANNA_BE_FOLLOWER",
 "NO_GUARD_AFFILIATION",
 "FOLLOW_ME",
 };
 
 
 class PursuingComm:public MIPObject{
  private:
   CommModule* _commModule;
   TaskPlate _taskPlate;
   uint _robotId;
   map <uint, PursuingMessageTypes> _lastSentDialogMessages;
   map <uint, PursuingMessageTypes> _lastReceivedDialogMessages;
   bool _automaticRepliesActivated;
   
   const PursuingStates* _currentStatePtr; // The Pursuing state cannot be modified by PursuingComm
   
   string _pursuingMessageTypesToString(PursuingMessageTypes messageType);
 
  
   PursuingMessageTypes _stringToPursuingMessageTypes(string messageType);
 
   
   bool _sendAPacket(uint recipientId, PursuingMessageTypes messageType,string serializedData);
   
   bool _sendAPacket(vector <uint> recipientIds, PursuingMessageTypes messageType,string serializedData);
   
   bool _checkOutgoingMessage(PursuingMessageTypes outgoingMessageType, int recipientId);
 
   bool _checkOutgoingMessage(string outgoingMessageType, int recipientId);
 
   bool _checkReceivedMessage(PursuingMessageTypes receivedMessage,int senderId);
 
   bool _checkReceivedMessage(string receivedMessageType, int senderId);
 
   void _updateLastSentDialogMessages(PursuingMessageTypes justSentMessage, uint recipientId);
   
   
   void _updateLastReceivedDialogMessages(PursuingMessageTypes justReceivedMessage, uint senderId);
 
   
   
   bool _outgoingPacketIsOutOfProtocol(CommPacket *packet);
 
   bool _receivedPacketIsOutOfProtocol(CommPacket * packet);
   
   bool _basicReceiveLastPacket(uint recipientId, PursuingMessageTypes messageType, string & message,bool withMessage);
   
   bool _receiveLastPacket(uint recipientId, PursuingMessageTypes messageType, string & message);
 
   
   bool _receiveLastPacket(uint recipientId, PursuingMessageTypes messageType);
   
   void _replyAutomatically(map<uint,PursuingMessageTypes> &asyncReqUniv);
   
  public:
   PursuingComm(CommModule* commModule, TaskPlate plate, PursuingStates* currentStatePtr);
 
   ~PursuingComm();
   
   void setAutomaticReplies(bool automaticRepliesActivated);
   
   bool getAutomaticReplies();
   
 
   string getObjectName() const {
    return "PursuingComm";
   }
  
   // Pose updating
   
   void sendCurrentPose(vector <uint> recipientIds, Pose currentPose);
   
 
   bool sendCurrentState(vector <uint> recipientIds, PursuingStates currentState);
 
   
   // Frontier updating
   
   bool sendGiveMeYourFrontier(uint recipientId);
   
   bool sendImNotAGuardAnymoreFrontier(uint recipientId);
   
   bool sendMyCurrentFrontier(uint recipientId, const vector < vector<Position> > & frontier);
   
   bool sendYourUpdatedFrontier(uint recipientId, const vector < vector<Position> > & frontier);
   
   // Follower commands
   
   bool sendCommandFollow(uint recipientId, Pose goal);
   
   bool sendCommandExpand(uint recipientId, Pose goal);
   
   bool sendCommandWander(uint recipientId);
   
   // Follower affiliation
   
   bool sendIWannaBeYourFollower(uint recipientId);
   
   bool sendFollowMe(uint recipientId);
   
   
   bool sendImNotAGuardAnymoreAffiliation(uint recipientId);
   
   // Receiving
 
   void receiveCurrentPoses(map<uint,TimeStampedPose> & poses);
   
   void receiveCurrentStates(map<uint,PursuingStates> & states);
 
   bool receiveCurrentFrontier(uint senderId, bool &positiveResponse, vector< vector<Position> > & frontier);
   
   bool receiveUpdatedFrontier(uint senderId,vector < vector<Position> > & frontier);
   
 
   bool receiveGuardAcknowledgmentAffiliation(uint supposedGuardId, bool &accepted);
   
   bool receiveFollowerCommands(uint guardId, bool &follow, bool &expand, bool &wander, Pose& goal);
   
   void receiveUniversAsyncRequests(map<uint,PursuingMessageTypes> & asyncReq);
 };
 
 /* @} */
 
};// end namespace MipTasks

#endif