broadcast.hpp

#ifndef DIY_PARTNERS_BROADCAST_HPP
#define DIY_PARTNERS_BROADCAST_HPP

#include "merge.hpp"

namespace diy
{

class Master;

struct RegularBroadcastPartners: public RegularMergePartners
{
  typedef       RegularMergePartners                            Parent; 

  template<class Decomposer>
                RegularBroadcastPartners(const Decomposer& decomposer,  
                                         int k,                         
                                         bool contiguous = true         
                    ):
                  Parent(decomposer, k, contiguous)         {}
                RegularBroadcastPartners(const DivisionVector&   divs,
                                         const KVSVector&        kvs, 
                                         bool  contiguous = true      
                    ):
                  Parent(divs, kvs, contiguous)               {}

  size_t        rounds() const                                  { return Parent::rounds(); }
  int           size(int round) const                           { return Parent::size(parent_round(round)); }
  int           dim(int round) const                            { return Parent::dim(parent_round(round)); }
  inline bool   active(int round, int gid, const Master& m) const { return Parent::active(parent_round(round), gid, m); }
  int           parent_round(int round) const                   { return rounds() - round; }

  // incoming is only valid for an active gid; it will only be called with an active gid
  inline void   incoming(int round, int gid, std::vector<int>& partners, const Master& m) const
  {
      Parent::outgoing(parent_round(round), gid, partners, m);
  }

  inline void   outgoing(int round, int gid, std::vector<int>& partners, const Master& m) const
  {
      Parent::incoming(parent_round(round), gid, partners, m);
  }
};

} // diy

#endif