p_vertices.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_VERTICES_HH
# define MLN_CORE_SITE_SET_P_VERTICES_HH


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



namespace mln
{

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


  namespace trait
  {

    template <typename G, typename F>
      struct site_set_< p_vertices<G,F> >
      {
        typedef trait::site_set::nsites::known   nsites;
        // FIXME: !
        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::vertex<G> > >
  class p_vertices
    : public internal::site_set_base_< mln_result(F), p_vertices<G,F> >
  {

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

  public:

    typedef G graph_t;

    typedef F fun_t;

    typedef util::vertex<G> vertex;


    typedef util::vertex<G> graph_element;


    p_vertices();

    p_vertices(const Graph<G>& gr);

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

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

    template <typename F2>
    p_vertices(const p_vertices<G,F2>& other);


    typedef mln_site(super_) element;

    typedef p_vertices_psite<G,F> psite;

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

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

    typedef fwd_piter piter;



    unsigned nsites() const;

    unsigned nvertices() const;

    bool is_valid() const;

    void invalidate();

    bool has(const psite& p) const;

    template <typename G2>
    bool has(const util::vertex<G2>& v) const;


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

    mln_result(F) operator()(const psite& p) const;
    mln_result(F) operator()(const util::vertex<G>& p) const;
    mln_result(F) operator()(unsigned id_v) const;

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

  private:
    G g_;
    F f_;
  };


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


  /* FIXME: Extend the `ord' mechanism instead of this ill-defined
     pseudo-order. */

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



# ifndef MLN_INCLUDE_ONLY

  template <typename G, typename F>
  inline
  p_vertices<G,F>::p_vertices()
    : f_(0)
  {
  }

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

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

  template <typename G, typename F>
  inline
  p_vertices<G,F>::p_vertices(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_vertices<G,F>::p_vertices(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>
  template <typename F2>
  inline
  p_vertices<G,F>::p_vertices(const p_vertices<G,F2>& other)
  {
    mln_precondition(other.is_valid());
    mlc_converts_to(F2,F)::check();

    g_ = other.graph();
    convert::from_to(other.function(), f_);
  }

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

  template <typename G, typename F>
  inline
  unsigned
  p_vertices<G,F>::nvertices() const
  {
    return this->g_.v_nmax();
  }

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

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

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

  template <typename G, typename F>
  template <typename G2>
  inline
  bool
  p_vertices<G,F>::has(const util::vertex<G2>& v) const
  {
    mln_precondition(is_valid());
    return
      // Check whether if the graph is 'compatible'.
      v.graph().is_subgraph_of(g_) &&
      g_.has(v) &&
      // Check that the vertex id of P belongs to the range of valid
      // vertex ids.
      (v.is_valid());
  }

//  template <typename G, typename F>
//  inline
//  bool
//  p_vertices<G,F>::has(unsigned vertex_id) const
//  {
//    mln_precondition(is_valid());
//    util::vertex<G> v(g_, vertex_id);
//    return has(v);
//  }

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

  template <typename G, typename F>
  inline
  mln_result(F)
  p_vertices<G,F>::operator()(const psite& p) const
  {
    mln_precondition(g_.has(p.v()));
    return (*this)(p.v().id());
  }

  template <typename G, typename F>
  inline
  mln_result(F)
  p_vertices<G,F>::operator()(const util::vertex<G>& v) const
  {
    mln_precondition(g_.has_v(v));
    return (*this)(v.id());
  }

  template <typename G, typename F>
  inline
  mln_result(F)
  p_vertices<G,F>::operator()(unsigned id_v) const
  {
    mln_precondition(g_.has_v(id_v));
    return f_(id_v);
  }

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

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

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

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

# endif // ! MLN_INCLUDE_ONLY

} // end of mln


#endif // ! MLN_CORE_SITE_SET_P_VERTICES_HH