---

PG_property_map.hpp

#ifndef _PG_PROPERTY_MAP_HPP_
#define _PG_PROPERTY_MAP_HPP_

#include <boost/pending/property.hpp>

namespace ParGraph
{
using boost::get_property_value;

template< class Tag, class Graph >
struct EdgeMap
{
  typedef Tag tag;
  typedef typename boost::property_value< typename Graph::VertexProperty, Tag >::type value_type;
  typedef typename value_type::edge_kind edge_kind;
  typedef typename value_type::property_type edge_property_type;
  typedef typename value_type::edge_type edge_type;
  typedef typename value_type::out_iterator out_iterator;
  typedef typename value_type::in_iterator in_iterator;
  typedef typename value_type::Edge Edge;
  typedef typename value_type::mapiterator mapiterator;
  typedef typename value_type::const_mapiterator const_mapiterator;
};


template< class Tag, class Graph >
EdgeMap< Tag, Graph >
get_edge_map( Tag, Graph )
{
  return EdgeMap< Tag, Graph >();
}

template< class T, class V, class G >
typename EdgeMap< T, G >::value_type::map_type &
get_out_edges( EdgeMap< T, G >, V v, G & g )
{
  return get_property_value( g.get_property_reference( v ), typename EdgeMap<T,G>::tag() ).out_edges;
};

template< class T, class G, class VProp >
typename EdgeMap< T, G >::value_type::map_type &
get_out_edges( EdgeMap< T, G >, VProp & vp )
{
  return get_property_value( vp, typename EdgeMap< T, G >::tag() ).out_edges;
}

template< class T, class G, class P >
inline typename EdgeMap< T, G >::value_type::map_type &
get_out_edges( EdgeMap< T, G >, DirectedInOutEdges<P> & el )
{
  return el.out_edges;
}

template< class T, class G, class P >
inline typename EdgeMap< T, G >::value_type::map_type &
get_out_edges( EdgeMap< T, G >, DirectedOutEdges<P> & el )
{
  return el.out_edges;
}

template< class T, class V, class G >
inline typename EdgeMap< T, G >::value_type::map_type &
get_in_edges( EdgeMap< T, G >, V v, G & g )
{
  return get_property_value( g.get_property_reference( v ), typename EdgeMap<T,G>::tag() ).in_edges;
};

template< class T, class G, class VProp >
typename EdgeMap< T, G >::value_type::map_type &
get_in_edges( EdgeMap< T, G >, VProp & vp )
{
  return get_property_value( vp, typename EdgeMap< T, G >::tag() ).in_edges;
}

template< class T, class G, class P >
inline typename EdgeMap< T, G >::value_type::map_type &
get_in_edges( EdgeMap< T, G >, DirectedInOutEdges<P> & el )
{
  return el.in_edges;
}

template< class Tag, class Graph >
struct ReverseEdgeMap
{
  typedef Tag tag;
  typedef typename boost::property_value< typename Graph::VertexProperty, Tag >::type value_type;
  typedef typename value_type::edge_kind edge_kind;
  typedef typename value_type::property_type edge_property_type;
  typedef typename value_type::edge_type edge_type;
  typedef typename value_type::in_iterator in_iterator;
  typedef typename value_type::out_iterator out_iterator;
  typedef typename value_type::Edge Edge;
  typedef typename value_type::mapiterator mapiterator;
  typedef typename value_type::const_mapiterator const_mapiterator;
};

template< class T, class V, class G >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_out_edges( ReverseEdgeMap< T, G >, V v, G & g )
{
  return get_property_value( g.get_property_reference( v ), typename ReverseEdgeMap<T,G>::tag() ).in_edges;
};

template< class T, class G, class VProp >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_out_edges( ReverseEdgeMap< T, G >, VProp & vp )
{
  return get_property_value( vp, typename ReverseEdgeMap< T, G >::tag() ).in_edges;
}

template< class T, class G, class P >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_out_edges( ReverseEdgeMap< T, G >, DirectedInOutEdges<P> & el )
{
  return el.in_edges;
}

template< class T, class V, class G >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_in_edges( ReverseEdgeMap< T, G >, V v, G & g )
{
  return get_property_value( g.get_property_reference( v ), typename ReverseEdgeMap<T,G>::tag() ).out_edges;
};

template< class T, class G, class VProp >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_in_edges( ReverseEdgeMap< T, G >, VProp & vp )
{
  return get_property_value( vp, typename ReverseEdgeMap< T, G >::tag() ).out_edges;
}

template< class T, class G, class P >
inline typename ReverseEdgeMap< T, G >::value_type::map_type &
get_in_edges( ReverseEdgeMap< T, G >, DirectedInOutEdges<P> & el )
{
  return el.out_edges;
}

template< class Filter, class Iterator >
class FilteredEdgeIterator
{
  typedef FilteredEdgeIterator< Filter, Iterator > self_type;
  Iterator iter, it_end;
  Filter f;
  void find_next()
  {
    while( iter != it_end )
    {
      if( f( *iter ) ) return;
      iter++;
    }
  }
public:
  FilteredEdgeIterator() {}
  FilteredEdgeIterator( Filter filter, Iterator & it, Iterator & end )
  {
    f = filter;
    it_end = end;
    iter = it;
    find_next();
  }
  void operator++(int)
  {
    iter++;
    find_next();
  }
  bool operator==( const self_type & other )
  {
    return iter == other.iter;
  }
  bool operator!=( const self_type & other )
  {
    return iter != other.iter;
  }
  typename Iterator::value_type operator* ()
  {
    return *iter;
  }
};

template< class Filter, class BaseEdgeMap >
struct FilteredEdgeMap
{
  Filter f;
  typedef typename BaseEdgeMap::tag tag;
  typedef typename BaseEdgeMap::value_type value_type;
  typedef typename BaseEdgeMap::edge_kind edge_kind;
  typedef typename BaseEdgeMap::edge_property_type edge_property_type;
  typedef typename BaseEdgeMap::edge_type edge_type;
  typedef typename BaseEdgeMap::Edge Edge;
  typedef FilteredEdgeIterator< Filter, typename BaseEdgeMap::out_iterator > out_iterator;
  typedef FilteredEdgeIterator< Filter, typename BaseEdgeMap::in_iterator > in_iterator;
  FilteredEdgeMap( Filter _f ) : f(_f) {}
};

template< class Graph, class V, class F, class B >
inline std::pair< typename FilteredEdgeMap<F,B>::out_iterator,
             typename FilteredEdgeMap<F,B>::out_iterator >
out_edges( Graph &g, V v, FilteredEdgeMap<F,B> m )
{
  typedef typename FilteredEdgeMap<F,B>::out_iterator Iter;
  pair< typename B::out_iterator, typename B::out_iterator > tmp =
      out_edges( g, v, B() );
  Iter it1 = Iter( m.f, tmp.first, tmp.second );
  Iter it2 = Iter( m.f, tmp.second, tmp.second );
  return std::make_pair( it1, it2 );
}

template< class T, class EdgeMap >
struct EdgePropertyMap
{
  typedef T tag;
  typedef EdgeMap edge_map;
  typedef typename boost::property_value< typename edge_map::value_type::property_type, tag >::type value_type;
};

template< class Tag, class EdgeMap >
EdgePropertyMap< Tag, EdgeMap >
get_edge_property_map( Tag, EdgeMap )
{
  return EdgePropertyMap< Tag, EdgeMap >();
};


template< class T, class M, class Iter >
typename EdgePropertyMap< T, M >::value_type &
get( EdgePropertyMap< T, M >, Iter iter )
{
  return get_property_value( get_edge_property(iter), typename EdgePropertyMap< T, M >::tag() );
};

template< class T, class M, class Iter >
void
put( EdgePropertyMap< T, M >, Iter iter, typename EdgePropertyMap< T, M >::value_type value)
{
  get_property_value( get_edge_property(iter), typename EdgePropertyMap< T, M >::tag() ) = value;
};


template< class T, class G >
struct VertexPropertyMap
{
  typedef T tag;
  typedef typename boost::property_value< typename G::VertexProperty, T >::type value_type;
};

template< class Tag, class Graph >
VertexPropertyMap< Tag, Graph >
get_vertex_property_map( Tag, Graph )
{
  return VertexPropertyMap< Tag, Graph >();
}

template< class Map, class Vertex, class Graph >
inline void
put( Map, Vertex v, Graph & g, typename Map::value_type value )
{
  get( Map(), g.get_property_reference( v ) ) = value;
}

template< class Map, class Vertex, class Graph >
inline typename Map::value_type &
get( Map, Vertex v, Graph & g )
{
  return get_property_value( g.get_property_reference( v ), typename Map::tag() );
}

template< class T, class P >
struct PropertyMap
{
  typedef T tag;
  typedef typename boost::property_value< P, T >::type value_type;
};

template< class Tag, class PropertyList >
PropertyMap< Tag, PropertyList >
get_property_map( Tag, PropertyList )
{
  return PropertyMap< Tag, PropertyList >();
}

template< class Map, class Property >
inline typename Map::value_type &
get( Map, Property & p )
{
  return get_property_value( p, Map::tag );
}

template< class Map, class Property >
inline void
put( Map, Property & p, typename Map::value_type value )
{
  get( Map(), p ) = value;
}

}
#endif // _PG_PROPERTY_MAP_HPP_

---