* make range and python filtering independently optional

* accept external files for property editing routines
* include in_PROP() andd out_PROP() functions to be used in python filtering/property editing routines.


git-svn-id: https://svn.forked.de/graph-tool/trunk@71 d4600afd-f417-0410-95de-beed9576f240

configure.in

@@ -99,20 +99,37 @@ AC_ARG_ENABLE([static-linkage], [AC_HELP_STRING([--enable-static-linkage],
         [AC_MSG_RESULT(no)] )
 AM_CONDITIONAL(STATIC, test $STATIC = yes)
 
-AC_MSG_CHECKING(whether to enable graph filtering...)
-                                                                                AC_ARG_ENABLE([filtering], [AC_HELP_STRING([--disable-filtering],
-        [disable graph filtering (range and python only) [default=no] ])],
+AC_MSG_CHECKING(whether to enable graph python filtering...)
+AC_ARG_ENABLE([python-filtering], [AC_HELP_STRING([--enable-python-filtering],
+        [enable python graph filtering [default=no] ])],
         if test $enableval = no; then
            [AC_MSG_RESULT(no)]
-           [AC_DEFINE([NO_FILTERING], 1, [disable graph filtering])]
-           NO_FILTERING=yes
+           [AC_DEFINE([NO_PYTHON_FILTERING], 1, [disable graph filtering])]
+           NO_PYTHON_FILTERING=yes
+        else
+           [AC_MSG_RESULT(yes)]
+        fi
+        ,
+        [AC_MSG_RESULT(no)]
+        [AC_DEFINE([NO_PYTHON_FILTERING], 1, [disable graph filtering])]
+        NO_PYTHON_FILTERING=yes
+        )
+
+AC_MSG_CHECKING(whether to enable graph range filtering...)
+AC_ARG_ENABLE([range-filtering], [AC_HELP_STRING([--disable-range-filtering],
+        [disable range filtering [default=no] ])],
+        if test $enableval = no; then
+           [AC_MSG_RESULT(no)]
+           [AC_DEFINE([NO_RANGE_FILTERING], 1, [disable range filtering])]
+           NO_RANGE_FILTERING=yes
         else
            [AC_MSG_RESULT(yes)]
         fi
         ,
         [AC_MSG_RESULT(yes)]
-        NO_FILTERING=no
+        NO_RANGE_FILTERING=no
         )
+
          
 dnl Checks for programs.
 

src/graph-tool

@@ -767,8 +767,12 @@ def parse_option(opt, just_file=False):
         if just_file:
             return None
         edit_vars = dict()
-        def edit_function():
-            return (eval(values[1],edit_vars))
+        if "file:" in values[1]:
+            exec open(values[1].replace("file:","").strip()).read() in edit_vars
+            edit_function = edit_vars["edit_function"]
+        else:
+            def edit_function():
+                return (eval(values[1],edit_vars))
         if opt.name == "edit-vertex-property":
             graph.EditVertexProperty(values[0],(edit_function,edit_vars))
         else:

src/graph/graph.cc

@@ -91,7 +91,7 @@ GraphInterface::~GraphInterface()
 
 void GraphInterface::SetVertexFilterProperty(string property)
 {
-#ifndef NO_FILTERING
+#ifndef NO_RANGE_FILTERING
     _vertex_filter_property = property;
     
     if (property != "")
@@ -119,7 +119,7 @@ void GraphInterface::SetVertexFilterProperty(string property)
         }
     }
 #else
-    throw GraphException("support for graph filtering was not enabled during compilation.");
+    throw GraphException("support for graph range filtering was not enabled during compilation.");
 #endif
 }
 
@@ -127,7 +127,7 @@ bool GraphInterface::IsVertexFilterActive() const { return _vertex_filter_proper
 
 void GraphInterface::SetEdgeFilterProperty(string property) 
 {
-#ifndef NO_FILTERING
+#ifndef NO_RANGE_FILTERING
     _edge_filter_property = property;
     
     if (property != "")
@@ -156,7 +156,7 @@ void GraphInterface::SetEdgeFilterProperty(string property)
     }
 
 #else
-    throw GraphException("support for graph filtering was not enabled during compilation.");
+    throw GraphException("support for graph range filtering was not enabled during compilation.");
 #endif
 }
 
@@ -164,29 +164,29 @@ bool GraphInterface::IsEdgeFilterActive() const {return _edge_filter_property !=
 
 void GraphInterface::SetVertexFilterRange(std::pair<double,double> allowed_range)
 {
-#ifndef NO_FILTERING
+#ifndef NO_RANGE_FILTERING
     _vertex_range = allowed_range;
 #else
-    throw GraphException("support for graph filtering was not enabled during compilation.");
+    throw GraphException("support for graph range filtering was not enabled during compilation.");
 #endif
 }
 
 
 void GraphInterface::SetGenericVertexFilter(boost::python::object filter) 
 {
-#ifndef NO_FILTERING
+#ifndef NO_PYTHON_FILTERING
     _vertex_python_filter = filter;
 #else
-    throw GraphException("support for graph filtering was not enabled during compilation.");
+    throw GraphException("support for graph python filtering was not enabled during compilation.");
 #endif    
 }
 
 void GraphInterface::SetGenericEdgeFilter(boost::python::object filter) 
 { 
-#ifndef NO_FILTERING
+#ifndef NO_PYTHON_FILTERING
     _edge_python_filter = filter;
 #else
-    throw GraphException("support for graph filtering was not enabled during compilation.");
+    throw GraphException("support for graph python filtering was not enabled during compilation.");
 #endif    
 }
 

src/graph/graph_filtering.hh

@@ -244,13 +244,14 @@ void check_filter(const GraphInterface &g, Action a, ReverseCheck, DirectedCheck
 {
     bool found = false;
 
-#ifndef NO_FILTERING
-
     typedef RangeFilter<GraphInterface::vertex_filter_map_t> vertex_filter_t;
     typedef RangeFilter<GraphInterface::edge_filter_map_t> edge_filter_t;
-    
+
+#ifndef NO_PYTHON_FILTERING
     if (g._edge_python_filter == python::object() && g._vertex_python_filter == python::object())
     {
+#endif
+#ifndef NO_RANGE_FILTERING        
         if (g._vertex_filter_property != "" && g._edge_filter_property != "")
         {        
             typedef filtered_graph<GraphInterface::multigraph_t, edge_filter_t, vertex_filter_t> fg_t;
@@ -273,16 +274,19 @@ void check_filter(const GraphInterface &g, Action a, ReverseCheck, DirectedCheck
         {
             mpl::for_each<DirectedCheck>(check_directed<GraphInterface::multigraph_t,Action,ReverseCheck>(g._mg, a, g._reversed, g._directed, found));
         }
+#else
+        mpl::for_each<DirectedCheck>(check_directed<GraphInterface::multigraph_t,Action,ReverseCheck>(g._mg, a, g._reversed, g._directed, found));
+#endif
+#ifndef NO_PYTHON_FILTERING
     }
     else
     {
         check_python_filter(g._mg, g, a, found, ReverseCheck(), DirectedCheck());
     }
-
-#else 
-
+#else
+#ifdef NO_RANGE_FILTERING
     mpl::for_each<DirectedCheck>(check_directed<GraphInterface::multigraph_t,Action,ReverseCheck>(g._mg, a, g._reversed, g._directed, found));
-
+#endif
 #endif
 
     if (!found)

src/graph/graph_python_filtering.hh

@@ -66,6 +66,17 @@ struct populate_python_funcs
 
         typedef typename mpl::if_<HasBase, degrees, mpl::vector<> >::type base_degrees;
         mpl::for_each<base_degrees>(put_base_degree_function<Graph>(g, v, variables, "orig_"));
+
+        for(typeof(dp.begin()) iter = dp.begin(); iter != dp.end(); ++iter)
+        {
+            if (iter->second->key() != typeid(typename graph_traits<Graph>::vertex_descriptor)) // FIXME: graph properties?x
+            {
+                variables["in_"+iter->first] = python::make_function(get_in_or_out_values<Graph,true>(g, *iter->second, v), 
+                                                                     python::default_call_policies(), mpl::vector<python::object>::type());
+                variables["out_"+iter->first] = python::make_function(get_in_or_out_values<Graph,false>(g, *iter->second, v), 
+                                                                      python::default_call_policies(), mpl::vector<python::object>::type());
+            }
+        }
     }
 
     template <class Graph>
@@ -125,6 +136,62 @@ struct populate_python_funcs
         python::object _retval;
     };
 
+    template <class Graph, bool In>
+    struct get_in_or_out_values
+    {
+        typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+        typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+
+        get_in_or_out_values(const Graph& g, dynamic_property_map& dmap, const vertex_descriptor& v)
+            : _g(g),_dmap(dmap),_v(v){}
+
+        python::object operator()()
+        {
+            if (In)
+                return get_in_props(_g, _v, typename is_convertible<typename graph_traits<Graph>::directed_category, undirected_tag>::type());
+            else
+                return get_out_props();
+        }
+
+        python::object get_out_props()
+        {
+            python::list props;
+            typename graph_traits<Graph>::out_edge_iterator e,e_end;
+            for (tie(e, e_end) = out_edges(_v, _g); e != e_end; ++e)
+            {
+                get_value<typename graph_traits<Graph>::edge_descriptor> value(_dmap, *e);
+                props.append(value());
+            }
+            return props;
+        }
+
+        template<class G>
+        python::object get_in_props(const G& g, typename graph_traits<G>::vertex_descriptor v, true_type)
+        {
+            python::list props;
+            typename graph_traits<G>::in_edge_iterator e,e_end;
+            for (tie(e, e_end) = in_edges(v, g); e != e_end; ++e)
+            {
+                get_value<typename graph_traits<Graph>::edge_descriptor> value(_dmap, *e);
+                props.append(value());
+            }
+            return props;
+        }
+        
+        
+        template<class G>
+        python::object get_in_props(const G& g, typename graph_traits<G>::vertex_descriptor v, false_type)
+        {
+            python::list props;
+            return props;
+        }
+
+        const Graph& _g;        
+        const dynamic_property_map& _dmap;
+        const vertex_descriptor& _v;        
+    };
+
+
     template <class Graph, bool Source>
     struct get_source_or_target_value
     {