p_edges.hh

// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (LRDE)
//
// This file is part of Olena.
//
// Olena is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, version 2 of the License.
//
// Olena is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free
// software project without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to produce
// an executable, this file does not by itself cause the resulting
// executable to be covered by the GNU General Public License.  This
// exception does not however invalidate any other reasons why the
// executable file might be covered by the GNU General Public License.

#ifndef MLN_CORE_SITE_SET_P_EDGES_HH
# define MLN_CORE_SITE_SET_P_EDGES_HH


# include <mln/core/concept/function.hh>
# include <mln/core/concept/graph.hh>
# include <mln/core/internal/site_set_base.hh>
# include <mln/core/site_set/p_graph_piter.hh>
# include <mln/core/site_set/p_edges_psite.hh>
# include <mln/util/graph.hh>
# include <mln/util/internal/id2element.hh>

# include <mln/metal/equal.hh>


namespace mln
{

  // Forward declaration.
  template <typename G, typename F> struct p_edges;


  namespace trait
  {
    template <typename G, typename F>
      struct site_set_< p_edges<G, F> >
      {
        // FIXME: I don't know what to use yet!
        typedef trait::site_set::nsites::known   nsites;
        typedef trait::site_set::bbox::unknown   bbox;
        typedef trait::site_set::contents::fixed contents;
        typedef trait::site_set::arity::unique   arity;
      };
  } // end of namespace mln::trait


  //
  template <typename G, typename F = util::internal::id2element<G,util::edge<G> > >
  class p_edges
    : public internal::site_set_base_< mln_result(F), p_edges<G, F> >
  {

    typedef p_edges<G, F> self_;
    typedef internal::site_set_base_< mln_result(F), self_ > super_;

  public:

    typedef G graph_t;

    typedef F fun_t;

    typedef util::edge<G> edge;

    typedef util::edge<G> graph_element;

    p_edges();

    p_edges(const Graph<G>& gr);

    p_edges(const Graph<G>& gr, const Function<F>& f);

    template <typename F2>
    p_edges(const Graph<G>& gr, const Function<F2>& f);

    typedef mln_site(super_) element;

    typedef p_edges_psite<G, F> psite;

    typedef p_graph_piter< self_, mln_edge_fwd_iter(G) > fwd_piter;

    typedef p_graph_piter< self_, mln_edge_bkd_iter(G) > bkd_piter;

    typedef fwd_piter piter;

    unsigned nsites() const;

    unsigned nedges() const;

    bool is_valid() const;
    void invalidate();

    bool has(const psite& p) const;

    template <typename G2>
    bool has(const util::edge<G2>& e) const;


    // FIXME: Dummy.
    std::size_t memory_size() const;

    const G& graph() const;
    const F& function() const;

  private:

    G g_;
    F f_;
  };


  template <typename G, typename F>
  bool
  operator==(const p_edges<G, F>& lhs, const p_edges<G, F>& rhs);


  template <typename G, typename F>
  bool
  operator<=(const p_edges<G, F>& lhs, const p_edges<G, F>& rhs);

} // end of mln


# ifndef MLN_INCLUDE_ONLY

namespace mln
{


  template <typename G, typename F>
  inline
  p_edges<G, F>::p_edges()
  {
  }

  template <typename G, typename F>
  inline
  p_edges<G, F>::p_edges(const Graph<G>& g)
  {
    typedef util::internal::id2element<G,util::edge<G> > F_REF;
    mlc_equal(F, F_REF)::check();

    mln_precondition(exact(g).is_valid());
    g_ = exact(g);
    f_ = util::internal::id2element< G, util::edge<G> >(g);
  }

  template <typename G, typename F>
  inline
  p_edges<G, F>::p_edges(const Graph<G>& g, const Function<F>& f)
  {
    mln_precondition(exact(g).is_valid());
    g_ = exact(g);
    f_ = exact(f);
  }

  template <typename G, typename F>
  template <typename F2>
  inline
  p_edges<G, F>::p_edges(const Graph<G>& g, const Function<F2>& f)
  {
    mln_precondition(exact(g).is_valid());
    mlc_converts_to(F2,F)::check();

    g_ = exact(g);
    convert::from_to(f, f_);
  }


  template <typename G, typename F>
  inline
  unsigned
  p_edges<G, F>::nsites() const
  {
    return nedges();
  }

  template <typename G, typename F>
  inline
  unsigned
  p_edges<G, F>::nedges() const
  {
    return this->g_.e_nmax();
  }

  template <typename G, typename F>
  inline
  bool
  p_edges<G, F>::is_valid() const
  {
    return g_.is_valid();
  }

  template <typename G, typename F>
  inline
  void
  p_edges<G, F>::invalidate()
  {
    g_.invalidate();
  }

  template <typename G, typename F>
  inline
  bool
  p_edges<G, F>::has(const psite& p) const
  {
    mln_precondition(is_valid());
    return has(p.e());
  }

  template <typename G, typename F>
  template <typename G2>
  inline
  bool
  p_edges<G, F>::has(const util::edge<G2>& e) const
  {
    mln_precondition(is_valid());
    return e.graph().is_subgraph_of(g_) && g_.has(e) && e.is_valid();
  }

//  template <typename G, typename F>
//  inline
//  bool
//  p_edges<G,F>::has(unsigned edge_id) const
//  {
//    mln_precondition(is_valid());
//    util::edge<G> e(g_, edge_id);
//    return has(e);
//  }

  template <typename G, typename F>
  inline
  std::size_t
  p_edges<G, F>::memory_size() const
  {
    // FIXME: Dummy; implement (see other site sets).
    abort();
    return 0;
  }

  template <typename G, typename F>
  inline
  const G&
  p_edges<G, F>::graph() const
  {
    mln_precondition(is_valid());
    return g_;
  }

  template <typename G, typename F>
  inline
  const F&
  p_edges<G, F>::function() const
  {
    return f_;
  }

  template <typename G, typename F>
  bool
  operator==(const p_edges<G, F>& lhs, const p_edges<G, F>& rhs)
  {
    return lhs.graph() == rhs.graph();
  }

  template <typename G, typename F>
  bool
  operator<=(const p_edges<G, F>& lhs, const p_edges<G, F>& rhs)
  {
    return lhs == rhs;
  }

} // end of mln

# endif // ! MLN_INCLUDE_ONLY

#endif // ! MLN_CORE_SITE_SET_P_EDGES_HH