template < typename T >
class StaticInterface
{
    public:
        StaticInterface()
        {
            int(*fooCheck)(int)     = T::foo;
            bool(*barCheck)(bool)   = T::bar;
        }
};

class DerivedClass : public StaticInterface<DerivedClass>
{
    public:
        static int foo(int  param){ return 10; }
        static bool bar(bool param){ return 20; }
};

/**
 * 	file		CInterfaceRegistry.h
 *  date:      Aug 11, 2009
 *  brief:
 *
 *  detail:
 */
 
#ifndef CINTERFACEREGISTRY_H_
#define CINTERFACEREGISTRY_H_
 
#include <map>
#include <string>
#include <set>
#include <typeinfo>
 
#include "exception/IllegalArgumentException.h"
 
namespace utility
{
 
 
/**
 *  brief  Generic singleton object to maintains a registry of subclasses
 *          that implement a particular interface
 *
 *  This clever solution was taken from the discussion at the following site:
 *  http://stackoverflow.com/questions/1260954/how-can-i-enumerate-all-
 *  classes-that-implement-an-interface
 *
 *  note:   The registry will allow the registration of any class that extends
 *          an interface so long as it has a factory method, but the
 *          RegisterWithInterface macro will only work with classes that have
 *          named that method create()
 *
 *
 */
template <typename InterfaceType>
class CInterfaceRegistry
{
    private:
        std::map< std::string, InterfaceType* (*)(void) > m_creatorMap;
 
 
        /**
         *  brief  private to ensure that only the singleton ( the single
         *          static instantiation ) of this template class is used
         */
        CInterfaceRegistry(){}
 
    public:
 
        /**
         *  brief  returns the registry instance particular to the specified
         *          interface (specified as template parameter)
         */
        static CInterfaceRegistry& getInstance();
 
 
        /**
         *  brief  registers a new subclass of a an interface
         */
        bool registerClass( const std::string& name,
                                InterfaceType* (*creator)(void) );
 
 
        /**
         *  brief  registers a new subclass from it's typeid() result, rather
         *          than from a hand-typed class name
         */
        bool registerClass( const std::type_info& classType,
                                InterfaceType* (*creator)(void) );
 
 
        /**
         *  brief  returns a list of classes registered with this interface
         */
        std::set<std::string>  getClassNames();
 
 
        /**
         *  brief  returns a new object of the specified class
         */
        InterfaceType*  createObjectOf( std::string className );
 
};
 
 
 
 
 
// A convient macro to compact the registration of a class
#define RegisterWithInterface( CLASS, INTERFACE )                   
namespace                                                           
{                                                                   
    bool dummy_ ## CLASS =                                          
    CInterfaceRegistry<INTERFACE>::getInstance().registerClass(     
            typeid(CLASS), CLASS::create );                         
}
 
 
/**
 *  The use of this method ensures that this template class remains singleton.
 *  Only the static registry object created by this method will exist for any
 *  instantiation of this class.
 */
template <typename InterfaceType >
CInterfaceRegistry<InterfaceType>& CInterfaceRegistry<InterfaceType>::getInstance()
{
    static CInterfaceRegistry<InterfaceType>    registry;
    return registry;
}
 
 
/**
 *  To register a class with this registry, we map a factory function that is
 *  capable of generating objects of the class and returning a pointer of the
 *  interface type. The key we map it to is the name of the class.
 */
template <typename InterfaceType >
bool CInterfaceRegistry<InterfaceType>::registerClass( const std::string& name,
                        InterfaceType* (*creator)(void) )
{
    m_creatorMap[name] = creator;
    return true;
}
 
 
/**
 *  For added convenience, we can avoid typing the class names by hand if we
 *  use the typeid() operator. This method will extract the class name from
 *  a type_info class and pass it on to the actual registration method.
 */
template <typename InterfaceType >
bool CInterfaceRegistry<InterfaceType>::registerClass( 
                        const std::type_info& classType,
                        InterfaceType* (*creator)(void) )
{
    return registerClass( std::string(classType.name()), creator );
}
 
 
/**
 *  To generate a list of the class names currently registered with this
 *  interface, we iterate through the map and extract all the keys.
 */
template <typename InterfaceType >
std::set<std::string>  CInterfaceRegistry<InterfaceType>::getClassNames()
{
    std::set<std::string>   keys;
 
    typename
    std::map< std::string, InterfaceType* (*)(void) >::iterator pair;
 
    for( pair = m_creatorMap.begin(); pair != m_creatorMap.end(); pair++)
        keys.insert( pair->first );
 
    return keys;
}
 
 
/**
 *  To create a new object of the specified class, we simply de-reference the
 *  stored factory method and execute it.
 */
template <typename InterfaceType >
InterfaceType*  CInterfaceRegistry<InterfaceType>::createObjectOf(
        std::string className )
{
    InterfaceType* (*creator)(void) = m_creatorMap[className];
 
    if(creator)
        return *creator();
    else
        throw IllegalArgumentException(
                className + "is not registered with the registry");
}
 
 
}
 
#endif /* CINTERFACEREGISTRY_H_ */

/**
 * 	file		CInterfaceRegistryTest.cpp
 *  date:      Aug 11, 2009
 *  brief:
 *
 *  detail:
 */
 
#include "utility/CInterfaceRegistry.h"
 
#include <iostream>
#include <map>
#include <set>
 
using namespace utility;
 
using std::map;
using std::set;
using std::cout;
using std::string;
 
 
 
// create the interface that we will be extending
class IDummyInterface{};
 
 
// create the first of several implementations of that interface
class CDerivedA : public IDummyInterface
{
    public:
        // the class must have some kind of static factory method
        static IDummyInterface* create(){ return new CDerivedA(); }
};
 
// and this is how we register the class with the registry
bool dummyA =
        CInterfaceRegistry<IDummyInterface>::getInstance().registerClass(
                "CDerivedA", CDerivedA::create );
 
 
// we create, here, the second of several implementations, it's basically the
// same as the first
class CDerivedB : public IDummyInterface
{
    public:
        // again with the static factory method
        static IDummyInterface* create(){ return new CDerivedB(); }
};
 
// this is the same as above
bool dummyB =
        CInterfaceRegistry<IDummyInterface>::getInstance().registerClass(
                "CDerivedB", CDerivedB::create );
 
 
// and a nother implementation
class CDerivedC : public IDummyInterface
{
    public:
        // ditto...
        static IDummyInterface* create(){ return new CDerivedC(); }
};
 
// this time we use that convenient macro that does things a little more
// compactly and, I think, without sacrificing readabilty
RegisterWithInterface( CDerivedC, IDummyInterface );
 
 
 
int main()
{
    // here we can retrieve a list of all the registered classes by
    // querying the registry object
    set<string> classes =
            CInterfaceRegistry<IDummyInterface>::getInstance().getClassNames();
 
    cout << "Currently registered subclasses of IDummyInterface: n";
    cout << "-- --------------------nn";
 
    set<string>::iterator   str;
    for( str = classes.begin(); str != classes.end(); str++ )
        cout << *str << "n";
 
    cout << "nndonen";
 
    return 0;
}

// A convient macro to compact the registration of a class
#define RegisterWithInterface( CLASS, INTERFACE )                   
namespace                                                           
{                                                                   
    bool dummy_ ## CLASS =                                          
    Registry<INTERFACE>::getInstance().registerClass(     
            #CLASS, CLASS::createNew );                               
}

template <typename T>
void CMatrix<T>::inPlaceTranspose(  )
{
    using std::swap;
 
    resize(cols,rows);
 
    int i, j, k, k_start, k_new;
    int n = rows;
    int m = cols;
 
    int length = rows*cols;
 
    for(k_start=1; k_start < length; k_start++)
    {
        T       temp    = data[k_start];
        bool    abort   = false;
        k_new = k = k_start;
 
        // go through the cycle once and ensure that the starting point is
        // minimal
        do
        {
            if( k_new < k_start )
            {
                abort = true;
                break;
            }
 
            k       = k_new;
            i       = k%n;
            j       = k/n;
            k_new   = i*m + j;
        }while(k_new != k_start);
 
 
        // if the current value is not the minimum of the cycle, then don't
        // perform the cycle
        if(abort)
            continue;
 
 
        // otherwise, perform the cycle
        k_new = k = k_start;
        do
        {
            swap<T>( data[k_new], temp );
 
            k       = k_new;
            i       = k%n;
            j       = k/n;
            k_new   = i*m + j;
        }while(k_new != k_start);
 
        swap<T>( data[k_new], temp );
    }
}