/// <summary>
 /// Construct a filtered graph with an edge and a vertex predicate.
 /// </summary>
 /// <param name="g">graph to filter</param>
 /// <param name="edgePredicate">edge predicate</param>
 /// <param name="vertexPredicate">vertex predicate</param>
 /// <exception cref="ArgumentNullException">
 /// g, edgePredicate or vertexPredicate are null
 /// </exception>
 public FilteredBidirectionalGraph(
     IBidirectionalGraph g,
     IEdgePredicate edgePredicate,
     IVertexPredicate vertexPredicate)
     : base(g,edgePredicate,vertexPredicate)
 {
 }

		/// <summary>
		/// Construct a graph that filters edges
		/// </summary>
		/// <param name="g">graph to filter</param>
		/// <param name="edgePredicate">edge predicate</param>
		/// <param name="vertexPredicate">vertex predicate</param>
		/// <exception cref="ArgumentNullException">
		/// g or edgePredicate or vertexPredicate is null
		/// </exception>
		public FilteredEdgeListGraph(
			IEdgeListGraph g, 
			IEdgePredicate edgePredicate,
			IVertexPredicate vertexPredicate
			)
			: base(g,edgePredicate,vertexPredicate)
		{}

 /// <summary>
 /// Construct a filtered graph with an edge and a vertex predicate.
 /// </summary>
 /// <param name="g">graph to filter</param>
 /// <param name="edgePredicate">edge predicate</param>
 /// <param name="vertexPredicate">vertex predicate</param>
 /// <exception cref="ArgumentNullException">
 /// g, edgePredicate or vertexPredicate are null
 /// </exception>
 public FilteredIncidenceGraph(
     IIncidenceGraph g,
     IEdgePredicate edgePredicate,
     IVertexPredicate vertexPredicate)
     : base(g,edgePredicate,vertexPredicate)
 {
 }

 /// <summary>
 /// Construct a graph that filters in-edges
 /// </summary>
 /// <param name="g">graph to filter</param>
 /// <param name="edgePredicate">edge predicate</param>
 /// <exception cref="ArgumentNullException">
 /// g or edgePredicate is null
 /// </exception>
 public FilteredVertexListGraph(
     IVertexListGraph g,
     IEdgePredicate edgePredicate
     )
     : base(g,edgePredicate)
 {
 }

 /// <summary>
 /// Construct a graph that filters edges and out-edges
 /// </summary>
 /// <param name="g">graph to filter</param>
 /// <param name="edgePredicate">edge predicate</param>
 /// <param name="vertexPredicate"></param>
 /// <exception cref="ArgumentNullException">
 /// g or edgePredicate is null
 /// </exception>
 public FilteredEdgeListAndIncidenceGraph(
     IEdgeListAndIncidenceGraph g,
     IEdgePredicate edgePredicate,
     IVertexPredicate vertexPredicate
     )
     : base(g,edgePredicate,vertexPredicate)
 {
     m_FilteredIncidenceGraph = new FilteredIncidenceGraph(g,edgePredicate,vertexPredicate);
 }

 /// <summary>
 /// Construct a filtered graph with an edge and a vertex predicate.
 /// </summary>
 /// <param name="g">graph to filter</param>
 /// <param name="edgePredicate">edge predicate</param>
 /// <param name="vertexPredicate">vertex predicate</param>
 /// <exception cref="ArgumentNullException">
 /// g, edgePredicate or vertexPredicate are null
 /// </exception>
 public FilteredGraph(
     IGraph g,
     IEdgePredicate edgePredicate,
     IVertexPredicate vertexPredicate)
 {
     Graph = g;
     EdgePredicate = edgePredicate;
     VertexPredicate = vertexPredicate;
 }

		/// <summary>
		/// Construct a graph that filters edges and vertices
		/// </summary>
		/// <param name="g">graph to filter</param>
		/// <param name="edgePredicate">edge predicate</param>
		/// <param name="vertexPredicate"></param>
		/// <exception cref="ArgumentNullException">
		/// g or edgePredicate is null
		/// </exception>
		public FilteredVertexAndEdgeListGraph(
			IVertexAndEdgeListGraph g,
			IEdgePredicate edgePredicate,
			IVertexPredicate vertexPredicate
			)
			: base(g,edgePredicate,vertexPredicate)
		{
			this.filteredEdgeList = new FilteredEdgeListGraph(g,edgePredicate);
		}

        /// <summary>
        /// Filtered edge collection
        /// </summary>
        /// <param name="ec">base collection</param>
        /// <param name="ep">filtering predicate</param>
        public FilteredEdgeEnumerable(EdgeCollection ec, IEdgePredicate ep)
        {
            if (ec == null)
                throw new ArgumentNullException("edge collection");
            if (ep == null)
                throw new ArgumentNullException("edge predicate");

            m_EdgeCollection = ec;
            m_EdgePredicate = ep;
        }

        /// <summary>
        /// Construct a new predicate.
        /// </summary>
        /// <param name="ep">the edge predicate</param>
        /// <param name="vp">the source vertex predicate</param>
        /// <exception cref="ArgumentNullException">ep or vp is null</exception>
        public InEdgePredicate(IEdgePredicate ep, IVertexPredicate vp)
        {
            if (ep == null)
                throw new ArgumentNullException("Edge predicate");
            if (vp == null)
                throw new ArgumentNullException("Vertex predicate");

            m_EdgePredicate = ep;
            m_VertexPredicate = vp;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="v"></param>
 /// <param name="ep"></param>
 /// <returns></returns>
 public IEdgeEnumerable SelectOutEdges(IVertex v, IEdgePredicate ep)
 {
     return Wrapped.SelectOutEdges(v,ep);
 }

 /// <summary>
 /// Creates a predicate that check the edge and the edge source
 /// </summary>
 /// <param name="ep">edge predicate to apply to the edge</param>
 /// <param name="vp">vertex predicate to apply to the edge source</param>
 /// <returns>in-edge predicate</returns>
 public static InEdgePredicate InEdge(IEdgePredicate ep, IVertexPredicate vp)
 {
     return new InEdgePredicate(ep,vp);
 }

 /// <summary>
 /// Creates a predicate that check the edge and the edge target
 /// </summary>
 /// <param name="ep">edge predicate to apply to the edge</param>
 /// <param name="vp">vertex predicate to apply to the edge target</param>
 /// <returns>out-edge predicate</returns>
 public static OutEdgePredicate OutEdge(IEdgePredicate ep, IVertexPredicate vp)
 {
     return new OutEdgePredicate(ep,vp);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="v"></param>
 /// <param name="ep"></param>
 /// <returns></returns>
 IEdgeEnumerable IFilteredBidirectionalGraph.SelectInEdges(IVertex v, IEdgePredicate ep)
 {
     return this.SelectInEdges(v,ep);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="e"></param>
 /// <param name="p"></param>
 public Enumerator(EdgeCollection.Enumerator e, IEdgePredicate p)
 {
     m_Enumerator = e;
     m_Predicate = p;
 }

 public virtual void RemoveEdgeIf(IEdgePredicate pred)
 {
     if (pred == null)
     {
         throw new ArgumentNullException("predicate");
     }
     EdgeCollection edges = new EdgeCollection();
     VertexEdgesEnumerator enumerator = this.Edges.GetEnumerator();
     while (enumerator.MoveNext())
     {
         IEdge edge = enumerator.get_Current();
         if (pred.Test(edge))
         {
             edges.Add(edge);
         }
     }
     EdgeCollection.Enumerator enumerator2 = edges.GetEnumerator();
     while (enumerator2.MoveNext())
     {
         IEdge e = enumerator2.get_Current();
         this.RemoveEdge(e);
     }
 }

        /// <summary>
        /// Returns the collection of out-edges that matches the predicate
        /// </summary>
        /// <param name="v"></param>
        /// <param name="ep">Edge predicate</param>
        /// <returns>enumerable colleciton of vertices that matches the 
        /// criteron</returns>
        /// <exception cref="ArgumentNullException">v or ep is null</exception>
        public FilteredEdgeEnumerable SelectOutEdges(IVertex v, IEdgePredicate ep)
        {
            if (v==null)
                throw new ArgumentNullException("vertex");
            if (ep==null)
                throw new ArgumentNullException("edge predicate");

            return new FilteredEdgeEnumerable(OutEdges(v),ep);
        }

        /// <summary>
        /// Remove all the out-edges of vertex u for which the predicate pred 
        /// returns true.
        /// </summary>
        /// <param name="u">vertex</param>
        /// <param name="pred">edge predicate</param>
        public virtual void RemoveOutEdgeIf(IVertex u, IEdgePredicate pred)
        {
            if (u==null)
                throw new ArgumentNullException("vertex u");
            if (pred == null)
                throw new ArgumentNullException("predicate");

            EdgeCollection edges = VertexOutEdges[u];
            EdgeCollection removedEdges = new EdgeCollection();
            foreach(IEdge e in edges)
                if (pred.Test(e))
                    removedEdges.Add(e);

            foreach(IEdge e in removedEdges)
                RemoveEdge(e);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="v"></param>
 /// <param name="ep"></param>
 /// <returns></returns>
 IEdgeEnumerable IFilteredIncidenceGraph.SelectOutEdges(IVertex v, IEdgePredicate ep)
 {
     return this.SelectOutEdges(v,ep);
 }

 /// <summary>
 /// Gets a filtered <see cref="IEdgeEnumerable"/> collection of edges.
 /// </summary>
 /// <param name="ep">edge predicate</param>
 /// <returns>filetered collection</returns>
 public IEdgeEnumerable SelectEdges(IEdgePredicate ep)
 {
     return Wrapped.SelectEdges(ep);
 }

        /// <summary>
        /// Remove out edge satisfying the predicate
        /// </summary>
        /// <param name="v"></param>
        /// <param name="ep"></param>
        public virtual void RemoveOutEdgeIf(IVertex v, IEdgePredicate ep)
        {
            if (v==null)
                throw new ArgumentNullException("v");
            if (ep==null)
                throw new ArgumentNullException("ep");

            Wrapped.RemoveOutEdgeIf(v,ep);
            if (Parent!=null)
                Parent.RemoveOutEdgeIf(v,ep);
        }