neighbor_set.h

这是一个著名的应用层组播中间件的源码

//Copyright (c) 2004, Charles Killian, Adolfo Rodriguez, Dejan Kostic, Sooraj Bhat, and Amin Vahdat
//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 names of Duke University nor The University of
//     California, San Diego, 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 COPYRIGHT OWNER 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.

#ifndef _NEIGHBOR_SET_H
#define _NEIGHBOR_SET_H

#include <algorithm>
#include "macedon.h"
#include <float.h>

template <class NeighborType, int MaxSize>
class neighbor_set
{
  public:
    int count;
    NeighborType entries[MaxSize];

    inline int maxsize() const {
      return MaxSize;
    }

    neighbor_set() : count(0) { }

    bool is_neighbor(int who) {
      return neighbor_entry(who) != NULL ;
    }

    NeighborType* neighbor_entry(int addr) {
      for (int i=0; i<count; i++)
        if (entries[i].ipaddr == addr)
          return &(entries[i]);
      return NULL;
    }

    NeighborType* neighbor_closest() {
      double best_delay = DBL_MAX;
      NeighborType *best_entry = NULL;
      for (int i=0; i<count; i++)
        if (entries[i].delay < best_delay)
        {
          best_delay = entries[i].delay;
          best_entry = &(entries[i]);
        }
      return best_entry;		
    }

    NeighborType* neighbor_worst() {
      double worst_delay = DBL_MIN;
      NeighborType *worst_entry = NULL;
      for (int i=0; i<count; i++)
        if (entries[i].delay > worst_delay)
        {
          worst_delay = entries[i].delay;
          worst_entry = &(entries[i]);
        }
      return worst_entry;		
    }

    void neighbor_clearit() {
      for (int i=0; i<MaxSize; i++)
        entries[i].neighbor_clearit();
      count = 0;
    }

    NeighborType* rand_neighbor() {
      if (count==0) return NULL;
      int i = random_integer(count);
      return &(entries[i]);
    }

    int serialize(char* buffer) {
      int position = 0;
      *((int*)buffer) = count;
      position += sizeof(int);
      for(int i=0; i<count; i++) {
        position += entries[i].neighbor_serialize(buffer+position);
      }
      return position;
    }

    int deserialize(char* buffer) {
      int position = 0;
      count = (int)(*buffer);
      position += sizeof(int);
      for(int i=0; i<count; i++) {
        position += entries[i].neighbor_deserialize(buffer+position);
      }
      return position;
    }

    template <class NeighborType2, int MaxSize2>
      neighbor_set<NeighborType,MaxSize>& operator= (const neighbor_set<NeighborType2, MaxSize2>& rhs)
      {
        for (int i=0; i<rhs.count; i++)
          (neighbor &) entries[i] = (neighbor &) rhs.entries[i];
        return *this;
      }
};

#endif // _NEIGHBOR_SET_H