AgentImporterExporter.h

/*
 * Repast for High Performance Computing (Repast HPC)
 *
 *   Copyright (c) 2010 Argonne National Laboratory
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with
 *   or without modification, are permitted provided that the following
 *   conditions are met:
 *
 *     Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *     Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 *     Neither the name of the Argonne National Laboratory nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  Created on: Jun 14, 2011
 *      Author: John T. Murphy
 */
 
#ifndef AGENTIMPORTEREXPORTER_H_
#define AGENTIMPORTEREXPORTER_H_
 
#include <map>
#include <set>
#include <list>
 
#include "AgentRequest.h"
#include "AgentId.h"
#include "AgentStatus.h"
#include "mpi_constants.h"
 
/*
 * If you wish to select the default
 * kind of Importer/Exporter, use one
 * of the valid values here (default
 * if not specified is 1):
 *
 *  1 = COUNT_LIST
 *  2 = COUNT_SET
 *  3 = LIST
 *  4 = SET
 *  5 = MAP(int)
 */
//#define DEFAULT_IMPORTER_EXPORTER 5
 
/*
 * If defined, allow multiple importer/exporter
 * instances managing distinct sets of agents
 */
#define SHARE_AGENTS_BY_SET
 
/*
 * If you wish to allow a single cancellation to be used
 * to cancel all of an agent's requests (for semantics
 * where multiple cancellations would ordinarily be
 * required), define this flag
 */
//#define ALLOW_FULL_AGENT_REQUEST_CANCELLATION
 
 
/* Preprocessor configuration */
 
#ifndef DEFAULT_IMPORTER_EXPORTER
  #define DEFAULT_IMPORTER_EXPORTER 4
#endif
 
#if DEFAULT_IMPORTER_EXPORTER < 1 || DEFAULT_IMPORTER_EXPORTER > 5
  #error "Invalid value used for default Importer_Exporter"
#endif
 
// If you are not permitting agent request by set,
// then only one of the importer_exporters should be compiled
// (The one chosen as the default)
#ifndef SHARE_AGENTS_BY_SET
 
  #if DEFAULT_IMPORTER_EXPORTER != 1 && !defined OMIT_IMPORTER_EXPORTER_COUNT_LIST
  #define OMIT_IMPORTER_EXPORTER_COUNT_LIST
  #endif
 
  #if DEFAULT_IMPORTER_EXPORTER != 2 && !defined OMIT_IMPORTER_EXPORTER_COUNT_SET
  #define OMIT_IMPORTER_EXPORTER_COUNT_SET
  #endif
 
  #if DEFAULT_IMPORTER_EXPORTER != 3 && !defined OMIT_IMPORTER_EXPORTER_LIST
  #define OMIT_IMPORTER_EXPORTER_LIST
  #endif
 
  #if DEFAULT_IMPORTER_EXPORTER != 4 && !defined OMIT_IMPORTER_EXPORTER_SET
  #define OMIT_IMPORTER_EXPORTER_SET
  #endif
 
  #if DEFAULT_IMPORTER_EXPORTER != 5 && !defined OMIT_IMPORTER_EXPORTER_MAP_int
  #define OMIT_IMPORTER_EXPORTER_MAP_int
  #endif
 
#endif
 
 
 
// Cannot set both 'default' and 'omit'; setting one
// as default overrides the omit
#if DEFAULT_IMPORTER_EXPORTER == 1
  #define DEFAULT_IMPORTER_EXPORTER_CLASS ImporterExporter_COUNT_LIST
  #define DEFAULT_ENUM_SYMBOL COUNT_LIST
  #undef OMIT_IMPORTER_EXPORTER_COUNT_LIST
#endif
 
#if DEFAULT_IMPORTER_EXPORTER == 2
  #define DEFAULT_IMPORTER_EXPORTER_CLASS ImporterExporter_COUNT_SET
  #define DEFAULT_ENUM_SYMBOL COUNT_SET
  #undef OMIT_IMPORTER_EXPORTER_COUNT_SET
#endif
 
#if DEFAULT_IMPORTER_EXPORTER == 3
  #define DEFAULT_IMPORTER_EXPORTER_CLASS ImporterExporter_LIST
  #define DEFAULT_ENUM_SYMBOL LIST
  #undef OMIT_IMPORTER_EXPORTER_LIST
#endif
 
#if DEFAULT_IMPORTER_EXPORTER == 4
  #define DEFAULT_IMPORTER_EXPORTER_CLASS ImporterExporter_SET
  #define DEFAULT_ENUM_SYMBOL SET
  #undef OMIT_IMPORTER_EXPORTER_SET
#endif
 
#if DEFAULT_IMPORTER_EXPORTER == 5
  #define DEFAULT_IMPORTER_EXPORTER_CLASS ImporterExporter_MAP_int
  #define DEFAULT_ENUM_SYMBOL MAP_int
  #undef OMIT_IMPORTER_EXPORTER_MAP_int
#endif
 
 
 
#ifdef SHARE_AGENTS_BY_SET
// This enum is useful when requests by set are allowed
// Result of this construction is enum AGENT_IMPORTER_EXPORTER_TYPE{ Default[, non-default1][, non-default2] }, with non-compiled classes omitted
enum AGENT_IMPORTER_EXPORTER_TYPE{ DEFAULT_ENUM_SYMBOL
#if !defined OMIT_IMPORTER_EXPORTER_COUNT_LIST && DEFAULT_IMPORTER_EXPORTER != 1
, COUNT_LIST
#endif
#if !defined OMIT_IMPORTER_EXPORTER_COUNT_SET && DEFAULT_IMPORTER_EXPORTER != 2
, COUNT_SET
#endif
#if !defined OMIT_IMPORTER_EXPORTER_LIST && DEFAULT_IMPORTER_EXPORTER != 3
, LIST
#endif
#if !defined OMIT_IMPORTER_EXPORTER_SET && DEFAULT_IMPORTER_EXPORTER != 4
, SET
#endif
#if !defined OMIT_IMPORTER_EXPORTER_MAP_int && DEFAULT_IMPORTER_EXPORTER != 5
, MAP_int
#endif
};
 
#define DEFAULT_AGENT_REQUEST_SET "__Default_Agent_Request_Set__"
 
#endif
 
/* END PREPROCESSOR */
 
 
#define REQUEST_AGENTS_ALL "AGENTS_FROM_ALL_IMPORTER_EXPORTERS"
 
 
namespace repast{
 
 
#ifndef SHARE_AGENTS_BY_SET
typedef std::map<int, AgentRequest*>  AgentExporterInfo;
#else
typedef std::map<std::string, std::map<int, AgentRequest*>* > AgentExporterInfo;
#endif
 
class AgentExporterData{
private:
  AgentExporterInfo empty; // Used as dummy for sending empty data
  std::map<int, AgentExporterInfo* > data;
 
#ifdef SHARE_AGENTS_BY_SET
  std::string selectedSet;
#endif
 
public:
  AgentExporterData();
  ~AgentExporterData();
 
  void addData(const AgentId& id, const int destProc, const int sourceProc,
      const int numberOfCopies = 1);
 
  AgentExporterInfo* dataForProc(int destProc);
 
  void clear();
 
  void removeAllDataForAgent(AgentId& id);
 
 
#ifdef SHARE_AGENTS_BY_SET
 
  void selectSet(std::string setName);
#endif
 
};
 
 
 
 
/* Importers */
 
#ifdef ALLOW_FULL_AGENT_REQUEST_CANCELLATION
 
void markIdAsFullCancellation(AgentId& id){
  id.currentRank(((-1) * id.currentRank()) - 1);
}
 
bool checkForFullCancellation(AgentId& id){
  if(id.currentRank() < 0){
    id.currentRank((id.currentRank() + 1) * (-1));
    return true;
  }
  else return false;
}
#endif
 
 
 
/* IMPORTER */
 
class AbstractImporter{
protected:
  // Each child implementation is required to maintain this list
  std::set<int> exportingProcesses;
 
public:
 
  AbstractImporter();
  virtual ~AbstractImporter();
 
  virtual const std::set<int>& getExportingProcesses(){ return exportingProcesses; }
 
  virtual void registerOutgoingRequests(AgentRequest &req) = 0;
 
  virtual void importedAgentIsRemoved(const AgentId& id) = 0;
 
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess) = 0;
 
  inline void importedAgentIsNowLocal(const AgentId& id){ importedAgentIsRemoved(id); }
 
  virtual std::string getReport() = 0;
 
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set) = 0;
 
  virtual void clear(){
    exportingProcesses.clear();
  }
};
 
 
#if !defined OMIT_IMPORTER_EXPORTER_COUNT_LIST || \
    !defined OMIT_IMPORTER_EXPORTER_COUNT_SET
 
class Importer_COUNT: public AbstractImporter{
 
private:
 std::map<int, int> sources;
 void incrementCount(int sourceProcess);
 void decrementCount(int sourceProcess);
 
public:
  Importer_COUNT();
  virtual ~Importer_COUNT();
 
  virtual void registerOutgoingRequests(AgentRequest &req);
  virtual void importedAgentIsRemoved(const AgentId& id);
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess);
 
  virtual std::string getReport();
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set);
};
#endif
 
#ifndef OMIT_IMPORTER_EXPORTER_LIST
 
class Importer_LIST: public AbstractImporter{
 
private:
  std::map<int, std::list<AgentId>* > sources;
 
  // Inline helper functions to manage the internal recordkeeping
 
  // Gets the record associated with the specified other process;
  // if none exists, one is created. 'exportingProcesses' is updated
  inline std::list<AgentId>* getRecord(int rank);
 
  // Removes all the entries for a given agent from the specified record;
  // Returns the number of entries removed
  // Also: Invokes 'checkRecord'
  inline int removeAll(const AgentId& id, std::list<AgentId>* record, int rank);
 
  // Removes one entry for a given ID (passes through to removeId by position)
  inline void removeID(AgentId& id, std::list<AgentId>* record, int rank);
 
  // Removes the entry at the specified position in the record list.
  // Also: Invokes 'checkRecord'
  inline void removeID(std::list<AgentId>::iterator idPosition, std::list<AgentId>* record, int rank);
 
  // Checks the length of this record; if the record is now empty,
  // it is removed from the map (and exportingProcesses is updated)
  inline void checkRecord(std::list<AgentId>* record, int rank);
 
public:
  Importer_LIST();
  ~Importer_LIST();
 
  virtual void registerOutgoingRequests(AgentRequest& req);
  virtual void importedAgentIsRemoved(const AgentId& id);
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess);
 
  virtual std::string getReport();
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set);
 
  virtual void clear(){
    AbstractImporter::clear();
    sources.clear();
  }
};
#endif
 
 
#ifndef OMIT_IMPORTER_EXPORTER_SET
 
class Importer_SET: public AbstractImporter{
private:
  std::map<int, std::set<AgentId>* > sources;
 
  // Helper functions to manage internal bookkeeping
 
  // Gets the record associated with the specified other
  // rank. If none exists, one is created (and exportingProcesses
  // is updated).
  inline std::set<AgentId>* getRecord(int rank);
 
  // Removes an ID from the specified set.
  // If this results in an actual removal, will return 1; if not,
  // will return zero. AgentID will not be in map after operation.
  // Also: Invokes checkRecord
  inline int removeID(const AgentId& id, std::set<AgentId>* record, int rank);
 
  // Checks the size of the record passed; if zero, deletes it from
  // the map and updates exportingProcesses
  inline void checkRecord(std::set<AgentId>* record, int rank);
 
public:
  Importer_SET();
  ~Importer_SET();
 
  virtual void registerOutgoingRequests(AgentRequest& req);
  virtual void importedAgentIsRemoved(const AgentId& id);
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess);
 
  virtual std::string getReport();
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set);
  virtual void clear(){
    AbstractImporter::clear();
    sources.clear();
  }
};
#endif
 
 
#ifndef OMIT_IMPORTER_EXPORTER_MAP_int
 
class Importer_MAP_int: public AbstractImporter{
private:
  std::map<int, std::map<AgentId, int>* > sources;
 
  // Helper functions to manage internal bookkeeping
 
  // Gets the record associated with the specified rank
  // If one does not exist, it is created, and exportingProcesses
  // is updated
  std::map<AgentId, int>* getRecord(int rank);
 
  // Removes the entry for the specified agent.
  // Returns the number associated with that agent (essentially the number of 'entries' removed)
  // Also: invokes checkRecord
  inline int removeAll(const AgentId& id, std::map<AgentId, int>* record, int rank);
 
  // Removes a single entry for the specified ID (decrements its count)
  // If the entry does not exist returns 0, otherwise
  // returns one (representing one entry removed)
  // Also: invokes checkRecord
  inline int removeID(const AgentId& id, std::map<AgentId, int>* record, int rank);
 
  // Removes the entire entry for a given agent, by position. Does not return
  // any indication of success of operation
  // Invokes checkRecord
  inline void removeID(std::map<AgentId, int>::iterator idPosition, std::map<AgentId, int>* record, int rank);
 
  // Checks if the record size is zero; if so, deletes it and notifies exportingProcesses
  inline void checkRecord(std::map<AgentId, int>* record, int rank);
 
 
public:
  Importer_MAP_int();
  ~Importer_MAP_int();
 
  virtual void registerOutgoingRequests(AgentRequest& req);
  virtual void importedAgentIsRemoved(const AgentId& id);
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess);
 
  virtual std::string getReport();
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set);
 
  virtual void clear(){
    AbstractImporter::clear();
    sources.clear();
  }
};
#endif
 
 
 
 
 
 
 
 
 
 
/* Exporters */
 
static std::vector<AgentStatus>    emptyStatus;
 
class AbstractExporter{
public:
  typedef std::map<int, std::set<AgentStatus> > StatusMap;
 
private:
  StatusMap*                  outgoingStatusChangesDeletePtr;
  AgentExporterData*          outgoingAgentExporterInformationDeletePtr;
 
protected:
  StatusMap*                  outgoingStatusChanges;
  AgentExporterData*          outgoingAgentExporterInformation;
 
  std::set<int>               processesExportedTo;
  std::map<int, AgentRequest> exportedMap;
 
public:
 
  AbstractExporter();
  virtual ~AbstractExporter();
 
  virtual void registerIncomingRequests(std::vector<AgentRequest>& requests) = 0;
 
  virtual void incorporateAgentExporterInfo(std::map<int, AgentRequest*> info);
 
 
  virtual void agentRemoved(const AgentId& id);
 
  virtual void agentMoved(const AgentId& id, int process);
 
  virtual const std::set<int>& getProcessesExportedTo();
 
  AgentExporterInfo* getAgentExportInfo(int destProc);
 
  const StatusMap* getOutgoingStatusChanges();
 
  void clearAgentExportInfo();
 
  void clearStatusMap();
 
  virtual const std::map<int, AgentRequest>& getAgentsToExport();
 
#ifdef SHARE_AGENTS_BY_SET
public:
  AbstractExporter(StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual std::string getReport() = 0;
 
  virtual void clear(){
    outgoingStatusChanges->clear();
    outgoingAgentExporterInformation->clear();
 
    processesExportedTo.clear();
    exportedMap.clear();
  }
 
  virtual void clearExportToSpecificProc(int rank){
    processesExportedTo.erase(rank);
    exportedMap.erase(rank);
  }
 
};
 
 
#if !defined OMIT_IMPORTER_EXPORTER_COUNT_LIST || \
    !defined OMIT_IMPORTER_EXPORTER_LIST       || \
    !defined OMIT_IMPORTER_EXPORTER_SET        || \
    !defined OMIT_IMPORTER_EXPORTER_MAP_int
 
class Exporter_LIST: public AbstractExporter{
private:
 
public:
  Exporter_LIST();
  virtual ~Exporter_LIST();
 
  virtual void registerIncomingRequests(std::vector<AgentRequest>& requests);
 
#ifdef SHARE_AGENTS_BY_SET
public:
  Exporter_LIST(StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual std::string getReport();
};
#endif
 
 
#ifndef OMIT_IMPORTER_EXPORTER_COUNT_SET
 
class Exporter_SET: public AbstractExporter{
 
public:
  Exporter_SET();
  virtual ~Exporter_SET();
 
  virtual void registerIncomingRequests(std::vector<AgentRequest>& requests);
 
#ifdef SHARE_AGENTS_BY_SET
public:
  Exporter_SET(StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual std::string getReport();
};
#endif
 
 
/* Importer and Exporter */
 
class AbstractImporterExporter{
 
protected:
  AbstractImporter* importer;
  AbstractExporter* exporter;
 
public:
  AbstractImporterExporter(AbstractImporter* i, AbstractExporter* e);
  virtual ~AbstractImporterExporter();
 
  // Pass-through methods for all importer and exporter public methods
  virtual const std::set<int>& getExportingProcesses(){                                            return importer->getExportingProcesses();               }
  virtual       void           registerOutgoingRequests(AgentRequest &req){                               importer->registerOutgoingRequests(req);         }
  virtual       void           importedAgentIsRemoved(const AgentId& id){                                 importer->importedAgentIsRemoved(id);            }
  virtual       void           importedAgentIsMoved(const AgentId& id, int newProcess){                   importer->importedAgentIsMoved(id, newProcess);  }
 
  virtual       void           importedAgentIsNowLocal(const AgentId& id){                                importer->importedAgentIsNowLocal(id);           }
 
  virtual       void           getSetOfAgentsBeingImported(std::set<AgentId>& set){                       importer->getSetOfAgentsBeingImported(set);      }
 
  virtual const AbstractExporter::StatusMap* getOutgoingStatusChanges();
 
  virtual const std::set<int>& getProcessesExportedTo(){                                           return exporter->getProcessesExportedTo();              }
  virtual       void           registerIncomingRequests(std::vector<AgentRequest>& requests){             exporter->registerIncomingRequests(requests);    }
  virtual       void           agentRemoved(const AgentId& id){                                           exporter->agentRemoved(id);                      }
  virtual       void           agentMoved(const AgentId& id, int process){                                exporter->agentMoved(id, process);               }
  virtual       void           incorporateAgentExporterInfo(std::map<int, AgentRequest* > info){          exporter->incorporateAgentExporterInfo(info);    }
  virtual       void           clearStatusMap(){                                                          exporter->clearStatusMap();                      }
  virtual AgentExporterInfo*   getAgentExportInfo(int destProc){                                   return exporter->getAgentExportInfo(destProc);          }
  virtual       void           clearAgentExportInfo(){                                                    exporter->clearAgentExportInfo();                }
  virtual const std::map<int, AgentRequest>& getAgentsToExport(){                                  return exporter->getAgentsToExport();                   }
 
  virtual void exchangeAgentStatusUpdates(boost::mpi::communicator comm, std::vector<std::vector<AgentStatus>* >& statusUpdates);
 
  virtual std::string version() = 0;
 
  virtual std::string getReport(){ return importer->getReport() + exporter->getReport(); }
 
  virtual void clear(){
    importer->clear();
    exporter->clear();
  }
 
  virtual void clearExporter(){
    exporter->clear();
  }
 
  virtual void clearExportToSpecificProc(int rank){
    exporter->clearExportToSpecificProc(rank);
  }
 
};
 
/* Normal variants, with semantics defined by which importer/exporter combination is used */
 
#ifndef OMIT_IMPORTER_EXPORTER_COUNT_LIST
 
class ImporterExporter_COUNT_LIST: public AbstractImporterExporter{
public:
  ImporterExporter_COUNT_LIST();
 
#ifdef SHARE_AGENTS_BY_SET
  ImporterExporter_COUNT_LIST(AbstractExporter::StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual ~ImporterExporter_COUNT_LIST();
 
  virtual std::string version();
 
};
#endif
 
#ifndef OMIT_IMPORTER_EXPORTER_COUNT_SET
 
class ImporterExporter_COUNT_SET: public AbstractImporterExporter{
public:
  ImporterExporter_COUNT_SET();
 
#ifdef SHARE_AGENTS_BY_SET
  ImporterExporter_COUNT_SET(AbstractExporter::StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual ~ImporterExporter_COUNT_SET();
 
  virtual std::string version();
};
#endif
 
#ifndef OMIT_IMPORTER_EXPORTER_LIST
 
class ImporterExporter_LIST: public AbstractImporterExporter{
public:
  ImporterExporter_LIST();
 
#ifdef SHARE_AGENTS_BY_SET
  ImporterExporter_LIST(AbstractExporter::StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual ~ImporterExporter_LIST();
 
  virtual std::string version();
};
#endif
 
#ifndef OMIT_IMPORTER_EXPORTER_SET
 
class ImporterExporter_SET: public AbstractImporterExporter{
public:
  ImporterExporter_SET();
 
#ifdef SHARE_AGENTS_BY_SET
  ImporterExporter_SET(AbstractExporter::StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual ~ImporterExporter_SET();
 
  virtual std::string version();
};
#endif
 
#ifndef OMIT_IMPORTER_EXPORTER_MAP_int
 
class ImporterExporter_MAP_int: public AbstractImporterExporter{
public:
  ImporterExporter_MAP_int();
 
#ifdef SHARE_AGENTS_BY_SET
  ImporterExporter_MAP_int(AbstractExporter::StatusMap* outgoingStatusMap, AgentExporterData* outgoingAgentExporterInfo);
#endif
 
  virtual ~ImporterExporter_MAP_int();
 
  virtual std::string version();
};
#endif
 
 
/* "BY SET" variant; allows multiple sets of shared agents to be managed independently */
 
#ifdef SHARE_AGENTS_BY_SET
 
class ImporterExporter_BY_SET: public AbstractImporterExporter{
 
private:
 
  AbstractExporter::StatusMap*                      outgoingStatusChanges;
  AgentExporterData*                                outgoingAgentExporterInformation;
  std::map<std::string, AbstractImporterExporter*>  importersExportersMap;
  std::set<int>                                     exportingProcesses;
  bool                                              exportingProcessesIsDirty;
  std::set<int>                                     processesExportedTo;
  bool                                              processesExportedToIsDirty;
  std::map<int, AgentRequest>                       exportedMap;
  bool                                              exportedMapIsDirty;
 
  AbstractImporterExporter* getSet(std::string setname,
      AGENT_IMPORTER_EXPORTER_TYPE setType = DEFAULT_ENUM_SYMBOL);
 
 
  inline void rebuildExportingProcesses(bool forceRebuild = false);
 
  inline void rebuildProcessesExportedTo(bool forceRebuild = false);
 
  inline void rebuildExportedMap(bool forceRebuild = false);
 
public:
  ImporterExporter_BY_SET();
 
  virtual ~ImporterExporter_BY_SET();
 
 
  /* Importer-related functions */
 
  virtual const std::set<int>& getExportingProcesses();
          const std::set<int>& getExportingProcesses(std::string setName);
 
 
  virtual void registerOutgoingRequests(AgentRequest& request);
          void registerOutgoingRequests(AgentRequest& request, std::string setName,
                     AGENT_IMPORTER_EXPORTER_TYPE setType = DEFAULT_ENUM_SYMBOL);
 
  virtual void importedAgentIsRemoved(const AgentId& id);
 
  virtual void importedAgentIsMoved(const AgentId& id, int newProcess);
 
  virtual void importedAgentIsNowLocal(const AgentId& id);
 
 
  /* Exporter-related functions */
 
  virtual const AbstractExporter::StatusMap* getOutgoingStatusChanges();
 
  virtual const std::set<int>& getProcessesExportedTo();
          const std::set<int>& getProcessesExportedTo(std::string setName);
 
  virtual void registerIncomingRequests(std::vector<AgentRequest>& requests);
          void registerIncomingRequests(std::vector<AgentRequest>& requests, std::string setName);
 
  virtual void agentRemoved(const AgentId& id);
  virtual void agentMoved(const AgentId& id, int newProcess);
 
  // This should NEVER be called; it is inappropriate to use this when 'by set' is being used
  virtual void incorporateAgentExporterInfo(std::map<int, AgentRequest* > info);
          void incorporateAgentExporterInfo(std::map<std::string, std::map<int, AgentRequest*>*>  info);
 
  virtual void clearStatusMap();
 
  virtual AgentExporterInfo* getAgentExportInfo(int destProc);
 
  virtual void clearAgentExportInfo();
 
  virtual const std::map<int, AgentRequest>& getAgentsToExport();
          const std::map<int, AgentRequest>& getAgentsToExport(std::string setName);
 
  virtual std::string version();
 
  void dropSet(std::string setName){
    importersExportersMap.erase(setName); // Fails silently if the specified set is not present
  }
 
  virtual std::string getReport(){
    std::stringstream ss;
    std::map<std::string, AbstractImporterExporter*>::iterator it    = importersExportersMap.begin();
    std::map<std::string, AbstractImporterExporter*>::iterator itEnd = importersExportersMap.end();
    while(it != itEnd){
      ss << it->first << "\n" << it->second->getReport();
      it++;
    }
    return ss.str();
  }
 
  virtual void getSetOfAgentsBeingImported(std::set<AgentId>& set);
  void getSetOfAgentsBeingImported(std::set<AgentId>& set, std::string excludeSet);
 
  virtual void clear(){
    std::map<std::string, AbstractImporterExporter*>::iterator it    = importersExportersMap.begin();
    std::map<std::string, AbstractImporterExporter*>::iterator itEnd = importersExportersMap.end();
    while(it != itEnd){
      it->second->clear();
      it++;
    }
  }
 
  void clear(std::string setName){
    std::map<std::string, AbstractImporterExporter*>::iterator it = importersExportersMap.find(setName);
    if(it != importersExportersMap.end()) it->second->clear();
  }
 
  virtual void clearExporter(){
    std::map<std::string, AbstractImporterExporter*>::iterator it    = importersExportersMap.begin();
    std::map<std::string, AbstractImporterExporter*>::iterator itEnd = importersExportersMap.end();
    while(it != itEnd){
      it->second->clearExporter();
      it++;
    }
  }
 
  void clearExporter(std::string setName){
    std::map<std::string, AbstractImporterExporter*>::iterator it = importersExportersMap.find(setName);
    if(it != importersExportersMap.end()) it->second->clearExporter();
  }
 
  void clearExportToSpecificProc(int rank){
    std::map<std::string, AbstractImporterExporter*>::iterator it    = importersExportersMap.begin();
    std::map<std::string, AbstractImporterExporter*>::iterator itEnd = importersExportersMap.end();
    while(it != itEnd){
      it->second->clearExportToSpecificProc(rank);
      it++;
    }
  }
 
};
#endif
 
}
#endif /* AGENTIMPORTEREXPORTER_H_ */