Simon Buchan wrote:
Played around a bit, try this. It only defines is_in (which wraps
'std::find(rhs.begin(), rhs.end(), lhs) != rhs.end()' ),
but should be easily generalisable to any operation, say:
if(x vec) {while(int i vec) cout << i;}
(I don't know if you could do the last one, or what syntax would be
better suited, but you get the idea)
Anything like "while(int i vec) cout << i;" isn't all that
feasible (without being really hackish), since you need to maintain some
sort of state inside of something that lives beyond each while
statement, but specifically not in for_all_in, since we want to be able
to iterate over the same container twice.
The best I can come up with is this: (This could be prettified if we
had auto, with the added bonus of allowing for autoselection of const
versus non-const iterators.)
for_all_in_iterator i;
while( i vec)
std::cout << *i << std::endl;
where for_all_in_iterator is essentially a specialized form of
boost::optional<>. I don't think you can get around using an iterator,
unless you're willing to sacrifice either for_all_in's reentry or status
as pseudo-keyword.
Either way, I added my code in, with a few edits to yours, to allow for
non-const RhsT. Ideally, there'd be a for_all_in_const_iterator version,
but that's pretty easy.
David Hall
#include <vector>
#include <algorithm>
#include <iostream>
#include <cassert>
namespace boost { namespace infix {
namespace detail {
template
struct binder
{
explicit binder(LhsT& _lhs)
: lhs(_lhs)
{}
template <typename RhsT>
typename Operator::template sig::type
operator > (RhsT& rhs)
{ return Operator::apply(lhs, rhs);
}
template <typename RhsT>
typename Operator::template sig::type
operator > (const RhsT& rhs)
{ return Operator::apply(lhs, rhs);
}
// SFINAE version of the above using ::result_type
// ...
private:
LhsT& lhs;
};
// lots of other things
}
struct is_in_operator
{ template
static bool
apply(const ValueT& val, const Cont& cont)
{ return std::find
( cont.begin()
, cont.end()
, val
) != cont.end();
}
template
struct sig
{ typedef bool type;
};
} is_in;
// Ugly version of the adapter pattern, perhaps too similar to boost::optional
// A state of valid implies that for_all_in has been applied to this iterator at least once.
template <class Cont>
class for_all_in_iterator
{
typedef typename Cont::iterator real_iter_t;
typedef typename Cont::value_type value_type;
public:
for_all_in_iterator():valid(false)
{}
for_all_in_iterator(const for_all_in_iterator & rhs)
: valid(rhs.valid), iter(rhs.iter)
{}
for_all_in_iterator(const real_iter_t & rhs)
: valid(false), iter(rhs)
{}
for_all_in_iterator & operator=(const real_iter_t & rhs)
{
iter = rhs;
return *this;
}
real_iter_t & operator->()
{
return iter;
}
const real_iter_t & operator->() const
{
return iter;
}
value_type & operator*()
{
return *iter;
}
const value_type & operator*() const
{
return *iter;
}
for_all_in_iterator & operator++()
{
++iter;
return *this;
}
for_all_in_iterator operator++(int)
{
for_all_in_iterator tmp(*this);
operator++();
return tmp;
}
bool operator==(const for_all_in_iterator & rhs) const
{
return iter == rhs.iter;
}
bool operator!=(const for_all_in_iterator & rhs) const
{
return iter != rhs.iter;
}
bool operator<(const for_all_in_iterator & rhs) const
{
return iter < rhs.iter;
}
bool operator>(const for_all_in_iterator & rhs) const
{
return iter > rhs.iter;
}
bool operator<=(const for_all_in_iterator & rhs) const
{
return iter <= rhs.iter;
}
bool operator>=(const for_all_in_iterator & rhs) const
{
return iter >= rhs.iter;
}
// Let's not be picky here.
template <class OtherIter>
bool operator==(const OtherIter & rhs) const
{
return iter == rhs;
}
template <class OtherIter>
bool operator!=(const OtherIter & rhs) const
{
return iter != rhs;
}
template <class OtherIter>
bool operator<(const OtherIter & rhs) const
{
return iter < rhs;
}
template <class OtherIter>
bool operator>(const OtherIter & rhs) const
{
return iter > rhs;
}
template <class OtherIter>
bool operator<=(const OtherIter & rhs) const
{
return iter <= rhs;
}
template <class OtherIter>
bool operator>=(const OtherIter & rhs) const
{
return iter >= rhs;
}
private:
bool valid;
real_iter_t iter;
friend class for_all_in_operator;
};
struct for_all_in_operator
{ template <typename Cont>
static bool
apply (for_all_in_iterator<Cont> & iter, Cont& cont)
{
if(!iter.valid)
{
iter.iter = cont.begin();
iter.valid = true;
return true;
}
if(iter.iter == cont.end())
return false;
return ++iter != cont.end();
}
template
struct sig
{ typedef bool type;
};
} for_all_in;
// Lots of other infix operators
template
detail::binder
operator < (LhsT& lhs, Operator rhs)
{ return detail::binder(lhs);
}
}}
int main()
{ using namespace boost::infix;
std::vector<int> vec;
int val = 6;
vec.push_back(4);
vec.push_back(7);
vec.push_back(6);
assert(val vec);
// The following could be a lot prettier with auto, oh well.
for_all_in_iterator i;
while( i vec)
std::cout << *i << std::endl;
}
