Projection.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.
 *
 *
 *  Projection.h
 *
 *  Created on: Aug 5, 2010
 *      Author: nick
 */
 
#ifndef PROJECTION_H_
#define PROJECTION_H_
 
#include <sstream>
#include <string>
#include <set>
#include <map>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/set.hpp>
 
#include "AgentId.h"
 
namespace repast {
 
 
class ProjectionInfoPacket{
  friend class boost::serialization::access;
 
public:
  ProjectionInfoPacket(){} // For serialization
  ProjectionInfoPacket(AgentId agentId): id(agentId){}
  virtual ~ProjectionInfoPacket(){}
 
  template<class Archive>
  void serialize(Archive& ar, const unsigned int version) {
    ar & id;
  }
 
  AgentId id;
 
  virtual bool isEmpty(){ return false; }
 
};
 
BOOST_SERIALIZATION_ASSUME_ABSTRACT(ProjectionInfoPacket);
 
template<typename Datum>
class SpecializedProjectionInfoPacket: public ProjectionInfoPacket{
  friend class boost::serialization::access;
 
public:
 
  SpecializedProjectionInfoPacket(){} // For serialization
  SpecializedProjectionInfoPacket(AgentId agentId): ProjectionInfoPacket(agentId){}
  SpecializedProjectionInfoPacket(AgentId agentId, std::vector<Datum> projectionData): ProjectionInfoPacket(agentId){
    data.assign(projectionData.begin(), projectionData.end());
  }
  SpecializedProjectionInfoPacket(AgentId agentId, std::set<Datum> projectionData): ProjectionInfoPacket(agentId){
    data.assign(projectionData.begin(), projectionData.end());
  }
 
  ~SpecializedProjectionInfoPacket(){}
 
  template<class Archive>
  void serialize(Archive& ar, const unsigned int version) {
    ar & boost::serialization::base_object<ProjectionInfoPacket>(*this);
    ar & data;
  }
 
  std::vector<Datum> data;
 
  virtual bool isEmpty(){ return (data.size() == 0); }
 
};
 
template<typename T>
class Context;
 
template<typename T>
class Projection : public boost::noncopyable {
 
        friend class Context<T> ;
 
protected:
 
        std::string name_;
        virtual bool addAgent(boost::shared_ptr<T> agent) = 0;
        virtual void removeAgent(T* agent) = 0;
 
 
        // Beta (Protected)
        std::set<int> filter;
 
 
  virtual ProjectionInfoPacket* getProjectionInfo(AgentId id, bool secondaryInfo = false, std::set<AgentId>* secondaryIds = 0, int destProc = -1 ) = 0;
 
  virtual void updateProjectionInfo(ProjectionInfoPacket* pip, Context<T>* context) = 0;
 
public:
 
  enum RADIUS{ PRIMARY, SECONDARY };
 
        Projection(std::string name) :
                name_(name) {
        }
 
        virtual ~Projection() {
        }
 
        const std::string name() const {
                return name_;
        }
 
        // Beta (public)
 
        void addFilterVal(int type){
          filter.insert(type);
        }
 
        void removeFilterVal(int type){
          filter.erase(type);
        }
 
        void clearFilter(){
          filter.clear();
        }
 
        bool agentCanBeAdded(boost::shared_ptr<T> agent){
          return ( (filter.size() == 0) ||
                   (filter.find(agent->getId().agentType()) != filter.end()));
        }
 
  virtual bool keepsAgentsOnSyncProj() = 0;
 
  virtual bool sendsSecondaryAgentsOnStatusExchange() = 0;
 
  virtual void getInfoExchangePartners(std::set<int>& psToSendTo, std::set<int>& psToReceiveFrom) = 0;
 
  virtual void getAgentStatusExchangePartners(std::set<int>& psToSendTo, std::set<int>& psToReceiveFrom) = 0;
 
  virtual void getRequiredAgents(std::set<AgentId>& agentsToTest, std::set<AgentId>& agentsRequired, RADIUS radius = PRIMARY) = 0;
 
  virtual void getAgentsToPush(std::set<AgentId>& agentsToTest, std::map<int, std::set<AgentId> >& agentsToPush) = 0;
 
  // Note: Virtual because some child classes may be able to short-circuit this (like Graphs)
  virtual void getProjectionInfo(std::vector<AgentId>& agents, std::vector<ProjectionInfoPacket*>& packets,
      bool secondaryInfo = false, std::set<AgentId>* secondaryIds = 0, int destProc = -1);
 
  void updateProjectionInfo(std::vector<ProjectionInfoPacket*>& pips, Context<T>* context);
 
  virtual void cleanProjectionInfo(std::set<AgentId>& agentsToKeep) = 0;
 
  virtual void balance(){};
 
};
 
 
template<typename T>
void Projection<T>::getProjectionInfo(std::vector<AgentId>& agents, std::vector<ProjectionInfoPacket*>& packets,
    bool secondaryInfo, std::set<AgentId>* secondaryIds, int destProc){
  for(std::vector<AgentId>::const_iterator iter = agents.begin(), iterEnd = agents.end(); iter != iterEnd; iter++){
    ProjectionInfoPacket* packet = getProjectionInfo((*iter), secondaryInfo, secondaryIds, destProc);
    if((packet != 0) && (!packet->isEmpty())) packets.push_back(packet);
  }
}
 
template<typename T>
void Projection<T>::updateProjectionInfo(std::vector<ProjectionInfoPacket*>& pips, Context<T>* context){
  for(std::vector<ProjectionInfoPacket*>::const_iterator pipIter = pips.begin(), pipIterEnd = pips.end(); pipIter != pipIterEnd; pipIter++){
      updateProjectionInfo(*pipIter, context);
  }
}
 
}
 
#endif /* PROJECTION_H_ */