This is the same protocol used by Google Authenticator – in fact, you can use their iOS/Android application to generate passwords for services that use this lib.

#!/usr/bin/env python
 
"""Implementation of RFC 4226: HMAC-Based One-Time Password Algorithm (HTOP),
and RFC 6238: Time-Based One-Time Password Algorithm (TOTP).
"""
 
__author__ = 'acoster'
__copyright__ = 'Copyright 2012, Alexandre Coster'
 
import hmac
import time
import base64
import struct
import hashlib
 
def get_hotp(secret, counter):
    """Return the HMAC-Based One-Time Password for the the given secret (base32 encoded) and the counter.
 
    >>> [get_hotp('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ', i) for i in xrange(10)]
    [755224, 287082, 359152, 969429, 338314, 254676, 287922, 162583, 399871, 520489]
    """
    secret  = base64.b32decode(secret)
    counter = struct.pack('>Q', counter)
 
    hash   = hmac.new(secret, counter, hashlib.sha1).digest()
    offset = ord(hash[19]) & 0xF
 
    return (struct.unpack(">I", hash[offset:offset + 4])[0] & 0x7FFFFFFF) % 1000000
 
def get_totp(secret):
    """Return the Time-Based One-Time Password for the current time, and the provided secret (base32 encoded)
 
       For obvious reasons, no unit-test is provided for this function.
    """
    return get_hotp(secret, int(time.time()) // 30)
 
if __name__ == '__main__':
    import doctest
    doctest.testmod()

class FactoryConstructible(object):
    def __init__(self, build_info):
        self.build_info = build_info
 
    @classmethod
    def create(cls, build_info, *args, **kwargs):
        for c in cls.__subclasses__():
            if c.supports_config(config):
                return c(config, *args, **kwargs)
        return None
 
    @classmethod
    def supports_config(cls, config):
        raise NotImplementedError()

A simple example of usage is shown below – naturally those classes are empty, but you can get the idea

class Shape(FactoryConstructible):
    pass
 
class Square(Shape):
    @classmethod
    def supports_config(self, config):
        return config == 'Square'
 
class Circle(Shape):
    @classmethod
    def supports_config(self, config):
        return config == 'Circle'
 
circle = Shape.create('Circle')
square = Shape.create('Square')

Declaring and using a wrapper is quite simple:

#include <math.h>
#include <iostream>
#include <functional>
 
struct SExample
{
    double operator()(double a, double b) { return a - b; }
};
 
int main(int, char **) 
{
    std::function<double(double, double)> fn; 
    SExample obj;
 
    fn = &pow;
    std::cout << fn(4, 4) << std::endl; // outputs 256
 
    fn = obj;
    std::cout << fn(4, 4) << std::endl; // outputs 0
 
    double x = 650;
    fn = [&] (double a, double b) -> double { return x + a * b; };
    std::cout << fn(4, 4) << std::endl; // outputs 666
}

As we can see, they behave quite closely to function pointers, but with a neater syntax and the advantage of accepting pretty much anything.

One interesting feature is that if the first parameter’s type is a class/struct,  the wrapper can be bound to a method of it,  so std::function will accept either functions/fuctors that match this signature, or pointers to a method of SExample that received a reference to a std::string, and returns a boolean, as we can see on the example below.

#include <math.h>
#include <iostream>
#include <functional>
 
struct SExample
{
    bool HandleCommand(const std::string& _rCommand)
    {   
        std::cout << "SExample::HandleCommand: " << _rCommand << std::endl;
        return true;
    }   
};
 
bool HandleCommand(SExample &, const std::string &_rCommand)
{
    std::cout << "::HandleCommand " << _rCommand << std::endl;
    return true;
}
 
int main(int, char **) 
{
    std::function<bool(SExample &, const std::string &)> fn; 
    SExample obj;
 
    fn = &HandleCommand;
    fn(obj, "rehash");&nbsp;// outputs "::HandleCommand rehash"
 
    fn = &SExample::HandleCommand;
    fn(obj, "rehash"); // outputs "SExample::HandleCommand: rehash"
}

Internally this is achieved by some template trickery, where the function’s first parameter’s type is separated from the other arguments, so the assignment operator can accept a member function. Naturally this doesn’t apply to static methods, which are functions with slightly different scoping/access rules.

You can check if an object is bound to a function by checking comparing it to NULL/nullptr, or simply using it as a boolean (it has an implicit cast operator defined).