FBB::FnWrap

libbobcat1-dev_2.10.03-x.tar.gz

2005-2010


FBB::FnWrap(3bobcat)

FBB::FnWrap(3bobcat)

libbobcat1-dev_2.10.03-x.tar.gz Configurable Function Wrapper

2005-2010

NAME

FnWrap - Generic configurable context function wrapper class

SYNOPSIS

#include <bobcat/fnwrap>

DESCRIPTION

The FBB::FnWrap class contains two static members: unary and binary. The unary function returns a unary functor that is ordinarily called from generic algorithms of the standard template libray expecting a unary functor or predicate. The binary function returns a binary functor that is ordinarily called from generic algorithms of the standard template libray expecting a binary functor or predicate.

The unary and binary functions expect the name of a (static or free) function that will be called from the functor's function operator. The arguments received by the functor's function operator are forwarded to the static or free function that is called by the functor's function operator.

Any additional arguments that are passed to unary or binary are forwarded to the function that is called by the functor's function operator. This allows users of FnWrap to pass a local context to the function that is indirectly called by a generic algorithm.

The number and types of arguments are determined by the parameter list of the function that is called by the functor's function operator. If that former function, in addition to parameters matching the types of the arguments provided by the generic algorithm also defines, e.g., an int and std::string & parameter then the FnWrap member functions must be called with the address of the function to call, with an int argument and with a std::string lvalue.

The type of the return value of the function whose address is passed to the FnWrap members will be the return type of the functor's function call operator. So if the generic algorithm expects a predicate function the function called by the functor's function call operator should return a bool value.

The called function must be a static member or free function. Using a static member or free function has several advantages over calling a non-static class member function:

NAMESPACE

FBB
All constructors, members, operators and manipulators, mentioned in this man-page, are defined in the namespace FBB.

INHERITS FROM

-

STATIC MEMBERS

TYPEDEFS

The functors defines types, that are used by generic algorithms:

EXAMPLES


    // accumulating strings from a vector to one big string, using
    // `accumulate'
    #include <iostream>
    #include <numeric>
    #include <string>
    #include <vector>
    #include <bobcat/fnwrap>
    
    using namespace std;
    using namespace FBB;
    
    class Strings
    {
        vector<string> d_vs;
    
        public:
            Strings()
            :
                d_vs({"one", "two", "three"})
            {}
    
            void display(ostream &out) const
            {
                size_t count = 0;
    
                cout << "On Exit: " <<
                    accumulate(
                        d_vs.begin(), d_vs.end(),
                        string("HI"),
                        FnWrap::binary(show, count, out)) << '\n';
                    
            }
    
        private:
            static string show(string const &str1,
                                    string const &str2,
                                    size_t &nr, ostream &out)
            {
                out << ++nr << " " << str1 << " " << str2 << '\n';

                return str1 + " " + str2;
            }
    };
    
    int main()
    {
        Strings s;
        s.display(cout);
    }
        
After compilation and linking, simply call the program without any arguments.

FILES

bobcat/fnwrap2c - defines the class interface

SEE ALSO

bobcat(7), fnwrap1(3bobcat), fnwrap2(3bobcat), fnwrap2(3bobcat), foreach(3bobcat), lc(3bobcat), repeat(3bobcat)

BUGS

None Reported.

DISTRIBUTION FILES

BOBCAT

Bobcat is an acronym of `Brokken's Own Base Classes And Templates'.

COPYRIGHT

This is free software, distributed under the terms of the GNU General Public License (GPL).

AUTHOR

Frank B. Brokken (f.b.brokken@rug.nl).