partmap.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 * NOTE: very generic partition container
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __PARTMAP__
#define __PARTMAP__
 
#include <map>
 
template<typename _linetype,typename _valuetype>
class partmap {
public:
  typedef std::map<_linetype,_valuetype> maptype;       
  typedef typename maptype::iterator iterator;          
  typedef typename maptype::const_iterator const_iterator;  
private:
  maptype database;                     
  _valuetype defaultvalue;                  
public:
  _valuetype &getValue(const _linetype &pnt);           
  const _valuetype &getValue(const _linetype &pnt) const;   
  const _valuetype &bounds(const _linetype &pnt,_linetype &before,_linetype &after,int &valid) const;
  _valuetype &split(const _linetype &pnt);          
  const _valuetype &defaultValue(void) const { return defaultvalue; }   
  _valuetype &defaultValue(void) { return defaultvalue; }       
  _valuetype & clearRange(const _linetype &pnt1,const _linetype &pnt2); 
  const_iterator begin(void) const { return database.begin(); }     
  const_iterator end(void) const { return database.end(); }     
  iterator begin(void) { return database.begin(); }         
  iterator end(void) { return database.end(); }             
  const_iterator begin(const _linetype &pnt) const { return database.lower_bound(pnt); }    
  iterator begin(const _linetype &pnt) { return database.lower_bound(pnt); }    
  void clear(void) { database.clear(); }                
  bool empty(void) const { return database.empty(); }           
};
 
template<typename _linetype,typename _valuetype>
  _valuetype &partmap<_linetype,_valuetype>::
  getValue(const _linetype &pnt)
  
  {
    iterator iter;
 
    iter = database.upper_bound(pnt);
    if (iter == database.begin())
      return defaultvalue;
    --iter;
    return (*iter).second;
  }
 
template<typename _linetype,typename _valuetype>
  const _valuetype &partmap<_linetype,_valuetype>::
  getValue(const _linetype &pnt) const
  
  {
    const_iterator iter;
    
    iter = database.upper_bound(pnt);
    if (iter == database.begin())
      return defaultvalue;
    --iter;
    return (*iter).second;
  }
 
template<typename _linetype,typename _valuetype>
  _valuetype &partmap<_linetype,_valuetype>::
  split(const _linetype &pnt)
 
  {
    iterator iter;
    
    iter = database.upper_bound(pnt);
    if (iter != database.begin()) {
      --iter;
      if ((*iter).first == pnt) // point matches exactly
    return (*iter).second;  // Return old ref
      _valuetype &newref( database[pnt] ); // Create new ref at point
      newref = (*iter).second;  // Copy of original partition value
      return newref;
    }
    _valuetype &newref( database[pnt] ); // Create new ref at point
    newref = defaultvalue;  // Copy of defaultvalue
    return newref;
  }
 
template<typename _linetype,typename _valuetype>
  _valuetype &partmap<_linetype,_valuetype>::
  clearRange(const _linetype &pnt1,const _linetype &pnt2)
  {
    split(pnt1);
    split(pnt2);
    iterator beg = begin(pnt1);
    iterator end = begin(pnt2);
    
    _valuetype &ref( (*beg).second );
    ++beg;
    database.erase(beg,end);
    return ref;
  }  
 
template<typename _linetype,typename _valuetype>
  const _valuetype &partmap<_linetype,_valuetype>::
  bounds(const _linetype &pnt,_linetype &before,_linetype &after,int &valid) const
  {
    if (database.empty()) {
      valid = 3;
      return defaultvalue;
    }
    const_iterator iter,enditer;
    
    enditer = database.upper_bound(pnt);
    if (enditer != database.begin()) {
      iter = enditer;
      --iter;
      before = (*iter).first;
      if (enditer == database.end())
    valid = 2;      // No upperbound
      else {
    after = (*enditer).first;
    valid = 0;      // Fully bounded
      }
      return (*iter).second;
    }
    valid = 1;          // No lowerbound
    after = (*enditer).first;
    return defaultvalue;
  }
#endif
 
#if 0
 
#include <iostream>
using namespace std;
 
int main(int argc,char **argv)
 
{
  partmap<int,unsigned int> data;
 
  data.defaultValue() = 0;
  data.split(5) = 5;
  data.split(2) = 2;
  data.split(3) = 4;
  data.split(3) = 3;
 
  cout << data.getValue(6) << endl;
  cout << data.getValue(8) << endl;
  cout << data.getValue(4) << endl;
  cout << data.getValue(1) << endl;
  
  partmap<int,unsigned int>::const_iterator iter;
 
  iter = data.begin(3);
  while(iter!=data.end()) {
    cout << (*iter).second << endl;
    ++iter;
  }
}
#endif