---

PG_vertex_sets.hpp

#ifndef _PG_VERTEX_SETS_HPP_
#define _PG_VERTEX_SETS_HPP_

namespace ParGraph
{

template< class Graph >
class SetWrapper
{
public:
  typedef std::set< typename Graph::KnownVertex > set_type;
private:
  set_type data;
  Graph & g;

public:
  SetWrapper( Graph & _g ) : data(), g(_g) {}

  pair<typename set_type::iterator, bool> insert( VertexID_t v )
  {
    return insert( g.get_known_vertex( v ) );
  }

// members of std::set -- nearly complete
// some constructors are missing, because they are not possible
// or should not be used
  typedef typename set_type::value_type value_type;
  typedef typename set_type::key_type key_type;
  typedef typename set_type::value_compare value_compare;
  typedef typename set_type::key_compare key_compare;
  typedef typename set_type::pointer pointer;
  typedef typename set_type::reference reference;
  typedef typename set_type::const_reference const_reference;
  typedef typename set_type::size_type size_type;
  typedef typename set_type::difference_type difference_type;
  typedef typename set_type::iterator iterator;
  typedef typename set_type::const_iterator const_iterator;
  typedef typename set_type::reverse_iterator reverse_iterator;
  typedef typename set_type::const_reverse_iterator const_reverse_iterator;

  iterator begin() const { return data.begin(); }
  iterator end() const { return data.end(); }
  reverse_iterator rbegin() const { return data.rbegin(); }
  reverse_iterator rend() const { return data.rend(); }
  size_type size() const { return data.size(); }
  size_type max_size() const { return data.max_size(); }
  bool empty() const { return data.empty(); }
  key_compare key_comp() const { return data.key_comp(); }
  value_compare value_comp() const { return data.value_comp(); }
  void swap( SetWrapper & s ) { data.swap( s.data ); }
  pair<iterator, bool> insert(value_type v)
  {
    pair<iterator, bool> r_val = data.insert( v );
    if( r_val.second == true )
        g.ink_known_vertex_counter( v );
    return r_val;
  }
  iterator insert( iterator pos, value_type v)
  {
    size_type presize = data.size();
    iterator r_val = data.insert( pos, v );
    if( presize != data.size() )
        g.ink_known_vertex_counter( v );
    return r_val;
  }
  template <class InputIterator>
  void insert(InputIterator it_begin, InputIterator it_end )
  {
    for( InputIterator it = it_begin ; it != it_end ; it++ )
        insert( *it );
  }
  size_type erase(const key_type& v)
  {
    if( data.erase( v ) > 0 )
        g.dek_known_vertex_counter( v );
    return 1;
  }
  void erase(iterator it)
  {
    g.dek_known_vertex_counter( *it );
    data.erase( it );
  }
  void erase(iterator first, iterator last)
  {
    for(; first != last ; first++ )
    {
      g.dek_known_vertex_counter( *first );
      data.erase( first );
    }
  }
  void clear()
  {
    for( iterator it = data.begin() ; it != data.end() ; it++ )
        g.dek_known_vertex_counter( *it );
    data.clear();
  }
  iterator find(key_type v) { return data.find(v); }
  size_type count(key_type v) const { return data.count(v); }
  iterator lower_bound(key_type v) const { return data.lower_bound(v); }
  iterator upper_bound(key_type v) const { return data.upper_bound(v); }
  std::pair< iterator, iterator > equal_range(key_type v) const { return data.equal_range(v); }
};

// Additional global Functions for VertexSets

template< class Graph >
typename Graph::VertexSetHandle
add_vertex_set( Graph & g )
{
  g.registered_vertex_sets.push_front( SetWrapper<Graph>(g) );
  return g.registered_vertex_sets.begin();
}

template< class Graph >
void
remove_vertex_set( Graph & g, typename Graph::VertexSetHandle h )
{
  g.registered_vertex_sets.erase( h );
}

template< class VertexSetHandle >
void
copy( VertexSetHandle h1, VertexSetHandle h2 )
{
  (*h2).clear();
  (*h2).insert( (*h1).begin(), (*h1).end() );
}

template< class VertexSetHandle, class Set >
void
copy( VertexSetHandle h1, Set & h2 )
{
  h2.clear();
  h2.insert( (*h1).begin(), (*h1).end() );
}

template< class KV, class VertexSetHandle >
bool
is_inside( KV v, VertexSetHandle h )
{
  return h->find(v) != h->end();
}

} // namespace ParGraph

#endif // _PG_VERTEX_SETS_HPP_

---