Re: Predicate template - is it possible?

From:

Greg Herlihy <greghe@mac.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Thu, 3 Jan 2008 20:19:19 CST

Message-ID:

<07df3880-3f62-4ca3-8c06-b0f32adceab0@d4g2000prg.googlegroups.com>

On Jan 1, 12:01 pm, "Tomasz Kalkosi?ski"
<tomasz.kalkosin...@gmail.com> wrote:

I use vectors and I use precidates to search them. I got many class-
predicate pairs like:

class MapConfiguration
    {
    public:
        std::string code;
        std::string name;
    } ;

class MapConfigurationByCode
    {
        private:
            const std::string code;

        public:
            MapConfigurationByCode (const std::string& code) :
                code (code)
            {}

            bool operator() (MapConfiguration* mapConfiguration)
            {
                return (mapConfiguration->code == this->code);
            }
    } ;

I have about ten predicates exactly like this for ten classes. They
differ by field type and field name to search: in some classes I look
for (int) id, in some of them I look for (std::string) name etc. I
thought that it would be nice to have predicate template so I could
generalise above example to:

typedef SearchPredicate<MapConfiguration, std::string, code>
MapConfigurationByCode;

(or others like typedef SearchPredicate<MapConfiguration, int, id>
PlayerById;)

I suggest using SearchPredicate's first two template parameters, "C"
and "T", to synthesize a third, non-type data member pointer
parameter, "F" - which would specify which of C's data members (of
type T) - is the one to be tested. For example:

    #include <iostream>
    #include <iomanip>
    #include <string>

    using std::string;
    using std::cout;

    template <class C, class T, T C::*F >
    class SearchPredicate
    {
    private:
        const T field;

    public:
        SearchPredicate( const T& f) :
            field(f) {}

        bool operator()( const C& item) const
        {
            return &item->*F == field;
        }
    };

    class MapConfiguration
    {
    public:
        string code;
        string name;
    };

    typedef SearchPredicate< MapConfiguration,
                             string,
                             &MapConfiguration::code>
            MapConfigurationByCode;

    typedef SearchPredicate< MapConfiguration,
                             string,
                             &MapConfiguration::name>
            MapConfigurationByName;

    int main()
    {
        MapConfigurationByCode predA("code A");
        MapConfigurationByName predB("name B");

        MapConfiguration mcA = { string("code A"), string("name A") };
        MapConfiguration mcB = { string("code B"), string("name B") };

        cout << std::boolalpha;

        cout << "predA applied to mcA is " << predA(mcA) << "\n";
        cout << "predA applied to mcB is " << predA(mcB) << "\n";

        cout << "predB applied to mcA is " << predB(mcA) << "\n";
        cout << "predB applied to mcB is " << predB(mcB) << "\n";
    }

Program Output:

    predA applied to mcA is true
    predA applied to mcB is false
    predB applied to mcA is false
    predB applied to mcB is true

Greg

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]