00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
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:
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:
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:
00048 inline valT value() const {
00049 return m_iter->second.second;
00050 }
00051
00052 private:
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:
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:
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
00086 if ( range != 0 && ( find( key ) || find( key + range ) ) ) {
00087 return true;
00088 }
00089
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
00098
00099 if ( m_map.empty() ) {
00100 return NULL;
00101 }
00102
00103
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
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