• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

sst/elements/include/memMap.h

00001 // Copyright 2009-2010 Sandia Corporation. Under the terms
00002 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
00003 // Government retains certain rights in this software.
00004 // 
00005 // Copyright (c) 2009-2010, Sandia Corporation
00006 // All rights reserved.
00007 // 
00008 // This file is part of the SST software package. For license
00009 // information, see the LICENSE file in the top level directory of the
00010 // distribution.
00011 
00012 
00013 #ifndef _MEMMAP_H
00014 #define _MEMMAP_H
00015 
00016 #include <map>
00017 
00018 template <typename keyT, typename rangeT, typename valT >
00019 class MemMap
00020 {
00021     private: // types
00022         typedef std::multimap< keyT, std::pair< rangeT, valT > > map_t;
00023 
00024     public:
00025         class iterator;
00026         friend class iterator;
00027         class iterator {
00028             public: // functions
00029                 iterator( ) : m_iter( NULL ) {
00030                 }
00031                 iterator( MemMap* mm ) : m_iter( mm->m_map.begin() ) {
00032                 }
00033                 iterator( MemMap* mm, bool ) : m_iter( mm->m_map.end() ) {
00034                 }
00035                 inline valT operator++(int) { 
00036                     valT tmp = value();
00037                     ++m_iter; 
00038                     return tmp;
00039                 }
00040                 inline valT operator*() const {
00041                     return value();
00042                 }
00043                 inline bool operator!=(const iterator& rv ) const {
00044                     return m_iter != rv.m_iter; 
00045                 } 
00046 
00047             private: // function
00048                 inline valT value() const { 
00049                     return m_iter->second.second;
00050                 }
00051 
00052             private: // data
00053                 typename MemMap::map_t::iterator m_iter;
00054         };
00055         inline iterator begin() { return iterator( this ); }
00056         inline iterator end() { return iterator( this, true); }
00057 
00058     public: // functions
00059         bool insert( keyT key, rangeT range, valT val );
00060         valT* find( keyT key );
00061         bool erase( keyT key );
00062         bool empty( );
00063         size_t size( );
00064 
00065     private: // data
00066         map_t   m_map;
00067 };
00068 
00069 template < typename keyT, typename rangeT, typename valT >
00070 inline bool MemMap< keyT, rangeT, valT >::empty( )
00071 {
00072     return m_map.empty();
00073 }
00074 
00075 template < typename keyT, typename rangeT, typename valT >
00076 inline size_t MemMap< keyT, rangeT, valT >::size( )
00077 {
00078     return m_map.size();
00079 }
00080 
00081 template < typename keyT, typename rangeT, typename valT >
00082 inline bool
00083 MemMap< keyT, rangeT, valT >::insert( keyT key, rangeT range, valT val )
00084 {
00085     //printf("insert key=%#lx range=%#lx\n",key,range);
00086     if ( range != 0 && ( find( key ) || find( key + range ) ) ) {
00087         return true;
00088     } 
00089     //printf("insert OK key=%#lx range=%#lx\n",key,range);
00090     m_map.insert( std::make_pair( key, std::make_pair( range, val) ) );
00091     return false;
00092 }
00093 
00094 template < typename keyT, typename rangeT, typename valT >
00095 inline valT* MemMap< keyT, rangeT, valT >::find( keyT key )
00096 {
00097     //printf("find key=%#lx\n",key);
00098 
00099     if ( m_map.empty() ) {
00100         return NULL;
00101     }
00102 
00103     // upper_bound will be the base key of the "next" region, hench "--" 
00104     typename map_t::iterator iter = m_map.upper_bound( key ); 
00105 
00106     --iter;
00107     std::pair< typename map_t::iterator, typename map_t::iterator> range;
00108     range = m_map.equal_range( iter->first );
00109 
00110     for ( iter = range.first; iter != range.second; ++iter )
00111     {
00112         //printf("find base=%lu range=%lu\n",iter->first, iter->second.first);
00113         if ( iter->second.first ) {
00114             if ( key >= iter->first && 
00115                         key < ( iter->first + iter->second.first ) )
00116             {
00117                 return &iter->second.second;
00118             }
00119         }
00120     } 
00121     return NULL;
00122 }
00123 
00124 #if 0
00125 template <typename keyT, typename rangeT, typename valT >
00126 inline bool MemMap< keyT, rangeT, valT >::erase( keyT key )
00127 {
00128     if ( m_map.find( key ) == m_map.end() ) {
00129         return true;
00130     }
00131     m_map.erase( key );
00132     return false;
00133 }
00134 #endif
00135 
00136 #endif

Generated on Fri Oct 22 2010 11:02:25 for SST by  doxygen 1.7.1