BeaconConsumer.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn 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.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_defs.h"

#include "BeaconConsumer.h"
#include "MobileNode.h"
#include "simlpy/Clock.h"

#include <vector>

using namespace Mobility;

BeaconConsumer::BeaconConsumer( MobileNode* owner ) :
   Consumer( &(owner->node()) ),
   m_mobileOwner( owner )
{
}

BeaconConsumer::~BeaconConsumer()
{
}

void
BeaconConsumer::operator()( const DTN::Bundle& b )
{
   // recv() takes care of everything we need to do.  The base class
   // requires that this be defined, though.
}

void
BeaconConsumer::send( const DTN::Bundle& b )
{
   if ( b.type() & DTN::Bundle::kBcast )
   {
      m_lastSend = Clock::time();
   }
}

void
BeaconConsumer::recv( const DTN::Bundle& b )
{
   const DTN::ByteString& addr = b.send();
   const Time& t = Clock::time();
   if ( m_neighbors.end() == m_neighbors.find(addr) )
   {
      m_mobileOwner->notifyApps(addr);
   }
   m_neighbors[addr] = t;
}

void
BeaconConsumer::setTimeout( const Time& t )
{
   m_timeout = t;
}

void
BeaconConsumer::clean()
{
   // Apparently, backing up in a map doesn't preserve the goodness
   // of an iterator when an erasure occurs.  So, we keep a to-erase
   // list separately.
   typedef std::vector< DTN::ByteString >  ErasureList;
   ErasureList  timedOut;
   Time lastGood = Clock::time() - m_timeout;
   NodeMap::iterator itr = m_neighbors.begin();
   for ( ; itr != m_neighbors.end() ; ++itr )
   {
      if ( itr->second < lastGood )
      {
         timedOut.push_back( itr->first );
      }
   }

   ErasureList::iterator eitr = timedOut.begin();
   ErasureList::iterator eend = timedOut.end();
   for ( ; eitr != eend ; ++eitr )
   {
      m_neighbors.erase( *eitr );
   }
}

bool
BeaconConsumer::visible( const DTN::ByteString& addr )
{
   NodeMap::iterator itr = m_neighbors.find( addr );
   if ( m_neighbors.end() == itr )
   {
      return false;
   }
   if ( itr->second + m_timeout < Clock::time() )
   {
      m_neighbors.erase(itr);
      return false;
   }
   return true;
}

InterpreterItem
BeaconConsumer::visible_list()
{
   clean();
   Entity::ArgList alist;
   NodeMap::iterator itr = m_neighbors.begin();
   for ( ; itr != m_neighbors.end() ; ++itr )
   {
      alist.push_back(
         PyString_FromStringAndSize( (const char*)(itr->first.data()),
                                     itr->first.length() ) );
   }
   return construct_list( alist );
}

---