FlatStore.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 "FlatStore.h"
#include "dtn/Bundle.h"
#include "dtn/Node.h"
#include "dtn/DropCause.h"
#include "simlpy/Time.h"

#include <iostream>

//============
// FlatStore
//============

FlatStore::FlatStore( DTN::Node* owner ) :
   DTN::VolatileBundleStore( owner ),
   m_bytesUsed(0)
{
}

FlatStore::~FlatStore()
{
   BundleList::iterator itr = m_list.begin();
   BundleList::iterator end = m_list.end();
   for ( ; itr != end ; ++itr )
   {
      if ( 0 != *itr ) delete *itr;
   }
}

DTN::BundlePointer
FlatStore::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 FlatStoreItr(*this,r.first) );
   }
   return DTN::BundlePointer();
}

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

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

DTN::BundlePointer
FlatStore::p_getPointer( const DTN::ByteString& sender, uint32_t seqNum )
{
   // Since we're just storing a set, sorted on memory address, we have
   // to do a slow iteration through the list.  This isn't a big deal,
   // as this method isn't likely to get called very often for this
   // type of BundleStore.
   BundleList::iterator itr = m_list.begin();
   BundleList::iterator end = m_list.end();
   for ( ; itr != end ; ++itr )
   {
      if ( 0 != *itr )
      {
         if ( ( (*itr)->source() == sender ) &&
              ( (*itr)->seqNum() == seqNum ) )
         {
            return DTN::BundlePointer( new FlatStoreItr(*this,itr) );
         }
      }
   }
   return DTN::BundlePointer();
}

bool
FlatStore::p_validatePointer( const DTN::BundlePointer& p )
{
   if ( p.isNull() ) return false;
   return ( m_list.end() != m_list.find( p.repr()->bundle() ) );
}

void
FlatStore::p_shrinkStore( size_t s )
{
   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;
      if ( 0 == *last ) return;
      Time tLast( (*last)->created() );
      for ( ; itr != end ; ++itr )
      {
         if ( 0 != *itr )
         {
            Time tItr( (*itr)->created() );
            if ( tItr > tLast )
            {
               last = itr;
            }
         }
      }
      p_deleteBundle(*last);
      m_owner->drop( *last, DTN::ExpiryDrop::inst );
   }
}

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

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

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

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

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

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

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

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


//===============
// FlatStoreItr
//===============

FlatStoreItr::FlatStoreItr( FlatStore& store,
                            FlatStore::BundleList::iterator itr ) :
   DTN::BundlePointerRepr(),
   m_store( store ),
   m_itr( itr )
{
}

FlatStoreItr::~FlatStoreItr()
{
}

bool
FlatStoreItr::operator==( const DTN::BundlePointerRepr& b )
{
   return b.bundle() == *m_itr;
}

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

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

DTN::Bundle*
FlatStoreItr::bundle() const
{
   return *m_itr;
}

---