STL adaptors help needed...

[SpOiLeR]

Hi there...

I have something like this:

#include <string>
#include <list>
#include <algorithm>

using namespace std;
typdef list<string> ls;

bool IsGood (const string& st);

struct AreGood
{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};

void remove_redundant_lines (ls& the_list)
{
ls::iterator lbeg, lend;
lbeg = the_list.begin();
lend = the_list.end();

the_list.erase (unique(lbeg, lend, AreGood()), lend);
}

Now remove_redundant_lines works as I expect it (removes subsequent strings
that satisfy IsGood from the_list). Here is my problem: I would like to do
it without AreGood functor. AreGood is used only in remove_redundant_lines
so introducing this struct just for that purpose seems to much. Could it be
done only with the use of IsGood? In this line:

unique(lbeg, lend, AreGood())

I wonder if some standard adaptor (or combination of those) could be used
instead of AreGood()? There is extension to STL adaptors available in SGI
STL named binary_compose which could (possibly) do what I want, but I don't
want to use SGI. So how would I do it with standard STL adaptors?

TIA

[AnonMail2005]

> struct AreGood

{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};

This functor looks fine. In fact, you should make it adaptable
by deriving it from the binary_function. This way, it is more
likely to be reused in the future.

[Greg]

SpOiLeR wrote:

Hi there...

I have something like this:

#include <string>
#include <list>
#include <algorithm>

using namespace std;
typdef list<string> ls;

bool IsGood (const string& st);

struct AreGood
{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};

void remove_redundant_lines (ls& the_list)
{
ls::iterator lbeg, lend;
lbeg = the_list.begin();
lend = the_list.end();

the_list.erase (unique(lbeg, lend, AreGood()), lend);
}

Now remove_redundant_lines works as I expect it (removes subsequent strings
that satisfy IsGood from the_list). Here is my problem: I would like to do
it without AreGood functor. AreGood is used only in remove_redundant_lines
so introducing this struct just for that purpose seems to much. Could it be
done only with the use of IsGood? In this line:

unique(lbeg, lend, AreGood())

I wonder if some standard adaptor (or combination of those) could be used
instead of AreGood()? There is extension to STL adaptors available in SGI
STL named binary_compose which could (possibly) do what I want, but I don't
want to use SGI. So how would I do it with standard STL adaptors?

TIA

Why do you need a functor?

void remove_redundant_lines(ls& the_list)
{
the_list.erase( std::unique(the_list.begin(), the_list.end()),
the_list.end());
}

Greg

[SpOiLeR]

On 16 Oct 2005 15:26:41 -0700, An**********@gmail.com wrote:

struct AreGood
{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};

This functor looks fine. In fact, you should make it adaptable
by deriving it from the binary_function. This way, it is more
likely to be reused in the future.

This would make sense if I could make it to use any unary predicate. How do
I do that?

template <class T, class un_pred>
struct AreEqualByPredicate
{
bool operator () (const T& s1, const T& s2) {
return un_pred(s1) == un_pred(s2);
}
}

might work, but not for IsGood in:

unique(lbeg, lend, AreEqualByPredicate<strting, IsGood>())

because IsGood should be functor, and I can't change that.

[SpOiLeR]

On 16 Oct 2005 22:58:12 -0700, Greg wrote:

Why do you need a functor?

void remove_redundant_lines(ls& the_list)
{
the_list.erase( std::unique(the_list.begin(), the_list.end()),
the_list.end());
}

Greg

I need it because I don't want unique to use default operator== for (in
this case) strings, but to check relation of equality using unary predicate
IsGood.

[Greg]

SpOiLeR wrote:

On 16 Oct 2005 22:58:12 -0700, Greg wrote:

Why do you need a functor?

void remove_redundant_lines(ls& the_list)
{
the_list.erase( std::unique(the_list.begin(), the_list.end()),
the_list.end());
}

Greg

I need it because I don't want unique to use default operator== for (in
this case) strings, but to check relation of equality using unary predicate
IsGood.

Nevertheless the simplest, cleanest solution is to rely on the equality
comparison to determine uniqueness. And if the std::string == operator
(which tests for identical strings) is not the true test for
equivalence, then the std::list does not really contain std::string's
but a "string-like" class that has its own semantics.

So I would formalize the distinction by writing a wrapper class to turn
the std::string into a different type (but with the same behavior as a
std::string). And then define the operator== (and whatever other
operators are needed) for this type:

class TextLine
{
private:
std::string mString;

public:
TextLine(const char *s) : mString(s) {}
...
bool operator==(const TextLine& rhs) const
{
return IsGood(this) == IsGood(rhs);
}
...

Of course this approach would seem overkill for the benefit of one
routine. But having equality and other comparison operators defined for
the type will simplify any code that iterates, tests, compares and
erases these types items. In other words, instead of writing "one-off"
functors throughout the program, implement a single, overloaded
operator instead that can be used in many different functions.

Greg

[SpOiLeR]

On 16 Oct 2005 23:32:07 -0700, Greg wrote:

SpOiLeR wrote:

On 16 Oct 2005 22:58:12 -0700, Greg wrote:

Why do you need a functor?

void remove_redundant_lines(ls& the_list)
{
the_list.erase( std::unique(the_list.begin(), the_list.end()),
the_list.end());
}

Greg

I need it because I don't want unique to use default operator== for (in
this case) strings, but to check relation of equality using unary predicate
IsGood.

Nevertheless the simplest, cleanest solution is to rely on the equality
comparison to determine uniqueness. And if the std::string == operator
(which tests for identical strings) is not the true test for
equivalence, then the std::list does not really contain std::string's
but a "string-like" class that has its own semantics.

So I would formalize the distinction by writing a wrapper class to turn
the std::string into a different type (but with the same behavior as a
std::string). And then define the operator== (and whatever other
operators are needed) for this type:

class TextLine
{
private:
std::string mString;

public:
TextLine(const char *s) : mString(s) {}
...
bool operator==(const TextLine& rhs) const
{
return IsGood(this) == IsGood(rhs);
}
...

Of course this approach would seem overkill for the benefit of one
routine. But having equality and other comparison operators defined for
the type will simplify any code that iterates, tests, compares and
erases these types items. In other words, instead of writing "one-off"
functors throughout the program, implement a single, overloaded
operator instead that can be used in many different functions.

Greg

To much work if I want to keep all good stuff that std::strting offers (I
would need to repeat interface of std::string, any global overloaded
operators and so on... unless I inherit from std::string which I don't know
if it's possible to do). But even then: single operator== wouldn't do. For
example, let it be that once IsGood checks if given string contains digits.
On the other time I want to have predicate that returns true only if given
string has certain number of given charaters... Or given string is exactly
length long... An so on. This is easilly achieved by writing unary/binary
predicates for all this situations, and then to have general binary
predicate that can take two strings and functor/predicate and check those
two strings for equallity by that predicate... Something like that is
impossible to achieve with operator== (or I could write a new class for
each that case which is really to much)

[red floyd]

An**********@gmail.com wrote:

struct AreGood
{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};

This functor looks fine. In fact, you should make it adaptable
by deriving it from the binary_function. This way, it is more
likely to be reused in the future.

Actually, it in addition to deriving from binary_function, operator()
should be a const member function.

i.e.

#include <functional>
#include <string>
using std::string;
using std::binary_function;

struct AreGood :
public binary_function<string,string,bool>
{
bool operator()(const string&s1, const string&s2) const
{
return IsGood(s1) == IsGood(s2);
}
};

As a side note, your implementation of AreGood will indicate s1 and s2
are good if they are both bad.

[SpOiLeR]

On Mon, 17 Oct 2005 17:09:46 GMT, red floyd wrote:

An**********@gmail.com wrote:

struct AreGood
{
bool operator () (const string& s1, const string& s2) {
return IsGood(s1) == IsGood(s2);
}
};
...

Actually, it in addition to deriving from binary_function, operator()
should be a const member function.

Point taken.
...
struct AreGood :
public binary_function<string,string,bool>
{
bool operator()(const string&s1, const string&s2) const
{
return IsGood(s1) == IsGood(s2);
}
};

As a side note, your implementation of AreGood will indicate s1 and s2
are good if they are both bad.

AreGood is name I made just for representation sake. I guess, better would
be AreEqualByPredicate... But name itself is not my biggest issue...