PersistentStore.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 "simlpy/interpreter_hooks.h"

#include "PersistentStore.h"
#include "WrapNode.h"
#include "dtn/Bundle.h"
#include "simlpy/Clock.h"

#include <iostream>


//===================
// PersistentBundle
//===================
PersistentBundle::PersistentBundle( DTN::Bundle* b ) :
   m_bundle( b ),
   m_timeAdded( Clock::time() ),
   m_numTries( 0 )
{
   if ( 0 != b )
   {
      m_originator = b->source();
      m_seqNum = b->seqNum();
   }
}

PersistentBundle::PersistentBundle( const DTN::ByteString& originator,
                                    uint32_t seqNum ) :
   m_bundle( 0 ),
   m_originator( originator ),
   m_seqNum( seqNum ),
   m_numTries( 0 )
{
}

PersistentBundle::~PersistentBundle()
{
}

DTN::Bundle*
PersistentBundle::bundle() const
{
   return m_bundle;
}

bool
PersistentBundle::operator<( const PersistentBundle& b ) const
{
   if ( m_originator < b.m_originator ) return true;
   if ( m_originator > b.m_originator ) return false;

   if ( m_seqNum < b.m_seqNum ) return true;
   if ( m_seqNum > b.m_seqNum ) return false;

   return false;
}


//==================
// PersistentStore
//==================

PersistentStore::PersistentStore( WrapNode* owner ) :
   DTN::PersistentBundleStore( &(owner->node()) ),
   m_bytesUsed(0),
   m_wowner( owner )
{
}

PersistentStore::~PersistentStore()
{
}

DTN::BundlePointer
PersistentStore::p_addBundle( DTN::Bundle* b )
{
   if ( 0 == b ) return DTN::BundlePointer();
   std::pair< BundleList::iterator , bool > r = m_list.insert( b );
   if ( r.second )
   {
      m_bytesUsed += b->size();
      return DTN::BundlePointer( new PersistentStoreItr(*this,r.first) );
   }
   return DTN::BundlePointer();
}

void
PersistentStore::p_deleteBundle( DTN::Bundle* b )
{
   if ( 0 == b ) return;
   if ( 0 != m_list.erase( b ) )
   {
      m_bytesUsed -= b->size();
   }
}

DTN::BundlePointer
PersistentStore::p_getPointer( const DTN::BundlePointer& p )
{
   if ( p.isNull() )
   {
      if ( m_list.empty() )
      {
         return DTN::BundlePointer();
      }
      return DTN::BundlePointer(
         new PersistentStoreItr(*this,m_list.begin()) );
   }
   BundleList::iterator itr = m_list.lower_bound( p.repr()->bundle() );
   if ( m_list.end() != itr )
   {
      return DTN::BundlePointer( new PersistentStoreItr(*this,itr) );
   }
   return DTN::BundlePointer();
}

DTN::BundlePointer
PersistentStore::p_getPointer( const DTN::ByteString& sender, uint32_t seqNum )
{
   BundleList::iterator itr = m_list.find( PersistentBundle(sender,seqNum) );
   if ( m_list.end() == itr )
   {
      return DTN::BundlePointer();
   }
   return DTN::BundlePointer( new PersistentStoreItr(*this,itr) );
}

bool
PersistentStore::p_validatePointer( const DTN::BundlePointer& p )
{
   if ( p.isNull() ) return false;
   BundleList::iterator itr = m_list.find( p.repr()->bundle() );
   if ( m_list.end() == itr ) return false;
   return true;
}

void
PersistentStore::p_shrinkStore( size_t s )
{
   // This loop is not efficient.  If we wanted to be efficient, we'd
   // store a separate list of bundles sorted by time added.  However,
   // we don't expect this to be called often, so a little
   // inefficiency here does no real harm.  This is, after all, fairly
   // major node reconfiguration.
   while ( m_bytesUsed > s )
   {
      if ( 0 == m_list.size() ) return;
      BundleList::reverse_iterator itr = m_list.rbegin();
      BundleList::reverse_iterator end = m_list.rend();
      BundleList::reverse_iterator last = itr;
      for ( ; itr != end ; ++itr )
      {
         if ( itr->timeAdded() > last->timeAdded() )
         {
            last = itr;
         }
      }
      m_owner->recordPersistentRemove( *(last->bundle()) );
      p_deleteBundle(last->bundle());
      delete last->bundle();
   }
}

PersistentStore::BundleList::iterator
PersistentStore::begin()
{
   return m_list.begin();
}

PersistentStore::BundleList::iterator
PersistentStore::lower_bound( const key_type& x )
{
   return m_list.lower_bound( x );
}

PersistentStore::BundleList::iterator
PersistentStore::upper_bound( const key_type& x )
{
   return m_list.upper_bound( x );
}

PersistentStore::BundleList::iterator
PersistentStore::end()
{
   return m_list.end();
}

PersistentStore::BundleList::const_iterator
PersistentStore::begin() const
{
   return m_list.begin();
}

PersistentStore::BundleList::const_iterator
PersistentStore::lower_bound( const key_type& x ) const
{
   return m_list.lower_bound( x );
}

PersistentStore::BundleList::const_iterator
PersistentStore::upper_bound( const key_type& x ) const
{
   return m_list.upper_bound( x );
}

PersistentStore::BundleList::const_iterator
PersistentStore::end() const
{
   return m_list.end();
}


//=====================
// PersistentStoreItr
//=====================

PersistentStoreItr::PersistentStoreItr(
   PersistentStore& store,
   PersistentStore::BundleList::iterator itr ) :
   DTN::BundlePointerRepr(),
   m_store( store ),
   m_itr( itr )
{
}

PersistentStoreItr::~PersistentStoreItr()
{
}

bool
PersistentStoreItr::operator==( const DTN::BundlePointerRepr& b )
{
   return false;
}

DTN::BundlePointerRepr*
PersistentStoreItr::next()
{
   PersistentStore::BundleList::iterator itr = m_store.upper_bound( *m_itr );
   if ( itr != m_store.end() )
   {
      return new PersistentStoreItr( m_store, itr );
   }
   return 0;
}

DTN::BundlePointerRepr*
PersistentStoreItr::clone()
{
   return new PersistentStoreItr( m_store, m_itr );
}

DTN::Bundle*
PersistentStoreItr::bundle() const
{
   return m_itr->bundle();
}

---