Is there a way to break out of boost::mpl for_each?

Question

Simple question really, let me give some background:

I have a mpl::vector of types where each type has an id, at run time I use the mpl::for_each to iterate through this vector and find the matching type for the given id. But once found, there is no point in continuing the loop, so - question is, is there a way to break out of it (without throwing an exception)?

Helenahelene

Answer 1

To implement something like find_if I changed the for_each (calling it exec_if) to take a bool template argument. The bool indicates if execution should with the next sequences, or in affect return early.

#include <iostream>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/assert.hpp>

namespace mpl = boost::mpl;

template< bool done = true >
struct exec_if_impl
{
  template<typename Iterator, typename LastIterator, typename Pred, typename Exec>
  static void execute(Iterator*, LastIterator*, Pred const&, Exec const&)
  {
  }
};

template<>
struct exec_if_impl<false>
{
  template<typename Iterator, typename LastIterator, typename Pred, typename Exec>
  static void execute(Iterator*, LastIterator*, Pred const& f, Exec const& e)
  {
    typedef typename mpl::deref<Iterator>::type item;

    if (!f(static_cast<item*>(0)))
    {
      typedef typename mpl::next<Iterator>::type iter;
      exec_if_impl<boost::is_same<iter, LastIterator>::value>
        ::execute(static_cast<iter*>(0), static_cast<LastIterator*>(0), f, e);
    }    
    else
      e(static_cast<item*>(0));
  }
};

template<typename Sequence, typename Pred, typename Exec>
inline
void exec_if(Pred const& f, Exec const& e, Sequence* = 0)
{
  BOOST_MPL_ASSERT(( mpl::is_sequence<Sequence> ));

  typedef typename mpl::begin<Sequence>::type first;
  typedef typename mpl::end<Sequence>::type last;

  exec_if_impl<boost::is_same<first,last>::value>
    ::execute(static_cast<first*>(0), static_cast<last*>(0), f, e);
}

namespace msg
{
  struct m1 { enum { TYPE = 1 }; static const char* name() { return "m1"; } };
  struct m2 { enum { TYPE = 2 }; static const char* name() { return "m2"; } };
  struct m3 { enum { TYPE = 3 }; static const char* name() { return "m3"; } };
  struct m4 { enum { TYPE = 4 }; static const char* name() { return "m4"; } };
  struct m5 { enum { TYPE = 5 }; static const char* name() { return "m5"; } };
}

struct checker
{
  checker(int chk_type) : type(chk_type) {}

  template <typename Mtype>
  bool operator()(Mtype* = 0) const
  {
    return Mtype::TYPE == type;
  }

  int type;
};

struct exec
{
  template <typename Mtype>
  void operator()(Mtype* = 0) const
  {
    std::cout << Mtype::name() << " executed" << std::endl;
  }
};

int main(void)
{
  typedef mpl::vector<msg::m1, msg::m2, msg::m3, msg::m4, msg::m5> mseq;

  checker chk(3); 

  exec_if<mseq>(chk, exec());

  return 0;
}

I changed this to exec_if, so now when the predicate matches, then the functor to execute will be triggered with the type - this does exactly what I need.

Helenahelene

Answer 2

Nope, there is no way to 'break' a mpl::for_each. That being said, I might have misunderstood your problem, but it seems to me you need mpl::find_if more than mpl::for_each :

#include <boost/mpl/find_if.hpp>
#include <boost/mpl/vector.hpp>

template<int N>
struct Foo { enum { id = N }; };

template<int N>
struct has_nested_id {
    template<class T>
    struct apply {
        static const bool value = (N == T::id);
    };
};

int main()
{
    typedef boost::mpl::find_if
        <
            boost::mpl::vector<Foo<1>, Foo<2>, Foo<3> >,
            has_nested_id<3>::apply<boost::mpl::_1>
        >::type iterator_type;

    typedef boost::mpl::deref<iterator_type>::type type; // result is Foo<3>
}

Lunde

I do need a find_if, but a runtime version rather than the meta one above. The problem I have is that 3 is only available at runtime. – Helenahelene

@Nim- MPL only works with compile-time constructs because templates can only be instantiated with values known at compile-time. If you don't know the index until runtime, you're going to have to use some other approach. – Veasey

@templatetypedef, yes I understand that, my current approach is to try to find the code for for_each and see if I can hack that, it somehow iterates through the types are runtime, so there has to be a way... – Helenahelene

I guess if you do an if + return inside, since the code gets expanded to many ifs, it should return early when taking a branch. – Stearin