Josh Bialkowski (Posts about Programming)

Range Based for-loops in C++11

Josh Bialkowski — Fri, 02 Aug 2013 14:07:04 GMT

One of the new features of C++11 that is a complete win in my opinion is the support for range-based for-loop syntax. Judicious use allows for significantly more compact and readable code. However, one thing that is lacking from this feature is the ability to iterate over a range of integers. This isn't a problem, however, because it is very easy to implement.

// This file compiles as a single unit, you can test it by saving it 
// as range_for.cpp and compiling with 
// g++ -std=c++11 -o range_for range_for.cpp
// Adjust the interface as you see fit

// Implementation (put this in a header)
// --------------------------------------------


/// encapsulates a range of integral numbers for use in a c++11 range-based for 
/// loop
template< typename T>
struct Range
{
    /// the begin() and end() functions must return an iterator with a specific
    /// interface
    struct Iterator
    {
        T val;  ///< storage for the actual value

        /// implicit construction from the value type
        Iterator( T val ):val(val){}

        /// the range-based for loops attempt to dereference an iterator using
        /// this operator
        T operator*(){ return val; }

        /// the range-based for loops quit when the comparison of iter != end
        /// returns false
        bool operator !=( T other ){ return val != other; }

        /// iterators in a range-based for loop must have the prefix increment
        /// operator
        Iterator& operator++(){ ++val; return *this; }

        /// we likely want to implicitly convert to the value type
        operator T(){ return val; }
    };

    private:
        T m_begin;  ///< the first integral value
        T m_end;    ///< one past the last integral value

    public:
        /// construct a range [begin, end)
        Range( T begin, T end ):
            m_begin(begin),
            m_end(end)
        {}

        /// interface required by range-based for loop
        Iterator begin(){ return m_begin; }

        /// interface required by range-based for loop
        Iterator end()  { return m_end;   }
};


/// return an object which can be used in a range-based for loop
template 
Range range( T begin, T end )
{
    return Range(begin,end);
}




// Usage 
// ---------------------------------------------

#include 

int main(int argc, char** argv)
{
    std::cout << "Static ranges\n----------------\n";
    std::cout << "\nint:\n";
    for( int i : range(1,5) )
        std::cout << "   i: " << i << "\n";

    std::cout << "\nunsigned int:\n";
    for( unsigned int i : range(1u,5u) )
        std::cout << "   i: " << i << "\n";

    std::cout << "\nlong:\n";
    for( long i : range(1L,5L) )
        std::cout << "   i: " << i << "\n";

    std::cout << "\nDynamic range (program args)\n----------------\n";
    for( int i : range(0,argc) )
        std::cout << i << " : " << argv[i] << "\n";

    return 0;
}

The range<T>( T begin, T end ) function template returns a Range&ltT> object which supports the required interface for range-based loops. It has a begin and end method, both of which return an iterator. The iterator has the same storage says as the integral type used to instantiate the templates. It is implicitly convertable to and from the integral type. Futhermore, it has the prefix ++ operator, and can be "dereferenced" to get the stored integral value.

The implementation is likely to yield compiled code equivalent to a normal for loop.

The output of the demo program above is:

josh@Nadie:~/Desktop$ g++ -std=c++11 -o range_for range_for.cpp 
josh@Nadie:~/Desktop$ ./range_for arg1 arg2 arg3 arg4 arg5
Static ranges
-----------

int:
   i: 1
   i: 2
   i: 3
   i: 4

unsigned int:
   i: 1
   i: 2
   i: 3
   i: 4

long:
   i: 1
   i: 2
   i: 3
   i: 4

Dynamic range (program args)
-----------
0 : ./range_for
1 : arg1
2 : arg2
3 : arg3
4 : arg4
5 : arg5
josh@Nadie:~/Desktop$

Exception Streams in C++

Josh Bialkowski — Sat, 02 Jun 2012 15:37:27 GMT

Here's a short but handy C++ Snippet. I was looking for a way to quickly generate runtime exceptions with useful information about the current program state. My process was:

Create a string stream
Build the message
Throw the exception using the string from the stream

I felt like this was particularly cumbersome and quite annoying, especially for doing things like string parsing or SQL because there are a lot of places in the code where error checking is required.

In any case, I came up with this simple little class tempate which sits in a single header file and is included in the cpp file where it is to be used.

#ifndef _UTILITY_EXCEPTIONSTREAM_H_
#define _UTILITY_EXCEPTIONSTREAM_H_

#include 
#include 

namespace utility   {

/// used to simplify the process of generating an exception message
/**
 *  Derives from stringstream so provides an ostream interface, but throws
 *  an exception with the contents of the string when the object is destroyed
 *
 *  \tparam Exception_t must be an exception type which accepts a
 *                      const char* in it's constructor
 *
 */
template 
class ExceptionStream :
    public std::stringstream
{
    public:
        ~ExceptionStream()
        {
            throw Exception_t( str().c_str() );
        }

        std::ostream& operator()()
        {
            return *this;
        }
};


typedef ExceptionStream ex;


} /* namespace utility */
#endif /* EXCEPTIONSTREAM_H_ */

Usage is like this:

ex fExp;

fExp = evalf( m_expression["radius"].subs(m_x == iRadius));
if( is_a(fExp) )
    radius= ex_to(fExp).to_double();
else
{
    utility::ex()() << "GiNaC failed to parse radius expression: "
                    << fExp;
}

Here I'm using GiNaC to parse a string into a mathematical expression. If the process fails I want to throw a runtime exception (typedef'ed as utility::ex).

The class derives from string stream so it works just like a string stream… building a string by catting together the RHS of all the string operators. The magic is that the destructor for the class throws an exception. The message for the exception is the string that was built.

It's a very handy time saver… though I'm not sure if it's actually safe to use. If the destructor throws an exception, is the object memory still freed?

directoryWatch

Josh Bialkowski — Thu, 18 Aug 2011 20:17:44 GMT

As I was working on texmake I decided that I didn't want to figure out what all the possible auxilary output files would be for a latex document. Also, I'm suspecting that it will depend on what packages are included and things. Anyway, I wanted a way to just monitor the build directory and see all the files that were created while running latex. It turns out this is very easy on linux. This is a very simple program which watches a directory, and will print out any files that are created, modified, opened, closed, moved, or deleted. It prints out the file name, followed by a comma, followed by the notification event.

You can find the code on github

HTML Documentation with Equation Numbers (Referencing an External PDF Document with Doxygen's HTML Documentation)

Josh Bialkowski — Sat, 17 Apr 2010 20:17:44 GMT

So, anyone who uses Doxygen to document their code knows that it's pretty much the most amazing thing ever. Seriously, it's awesome. One cool thing about it is the ability to reference external documentation. For instance, if you use a library in your code and you want to include the library's documentation with your own. However, let's say that (hypothetically of course) you're an academic… and the code you write implements some theoretical design or model. In that case, you may actually want your documentation to reference a paper, or a report that you've written. Perhaps, even many such papers or reports.

The Problem

In particular, let's say that you're a grad student, in the process of writing a paper (and of course, you used LaTex… because, well, why wouldn't you?) and you go and write some code to simulate or demonstrate some elements of that paper. In that case, some of your functions may implement certain equations. Some of your classes (if it's object oriented) may implement certain models. For an example, lets say this is your paper:

Let's also assume that you've been good, and have been documenting your code with Doxygen. Let's say you had some c++ class that implemented your model and it's definition looks something like this:

/**
 *  file       CTheoreticalModel.h
 *  author     Joe Author (jauthor@institute.edu)
 *  date       Apr 17, 2010
 *  brief      Definition file for CTheoreticalModel class
 */

#ifndef CTHEORETICALMODEL_H_
#define CTHEORETICALMODEL_H_


/**
 *  brief  Theoretical Model derived in section 2, on page 1
 *
 *  This is a detailed description of the model
 */
class CTheoreticalModel
{
    private:
        double    m_alpha;    ///< [parameter] defined in equation 2.1
        double    m_beta;     ///< [parameter] defined in equation 2.2

    public:
        /**
         *  brief      Construct a new model using the given parameters
         *  param[in]  alpha   [parameter] defined in equation 2.1
         *  param[in]  beta    [parameter] defined in equation 2.2
         */
        CTheoreticalModel( double alpha, double beta );


        /**
         *  brief      calculates [some property] by implementing algorithm 2.1
         *              on page 1
         *  return     [some property]
         */
        double algorithmA();


        /**
         *  brief      updates the model by [some parameter] according to the
         *              dynamics of equation 2.4
         *  param[in]  gamma   [parameter] defined in equation 2.3
         */
        void equationB( double gamma );


        /**
         *  brief      tests [some parameter] against the model; implements
         *              equation 2.6
         *  param[in]  theta   [some parameter] defined by equation 2.5
         */
        bool testC( double theta );
};

#endif /* CTHEORETICALMODEL_H_ */

Then the html documentation that doxygen will generate will look like this:

Now let's say that you talk to your advisor and he suggests that maybe section 2 should come after section 3. Moreover, you add a bunch of content to section 1 so now all of the code for this model is on page five. So then you end up with this:

So now you have to go back and change all of the equation numbers and page references in your code. But wait, when we wrote our document we "label{}"ed all of our equations, algorithms, and sections. Wouldn't it be cool if we could just reference those in the comments? Doxygen exposes latex's math mode for us to document inline equations. It uses latex to render the equations, and then uses dvipng to turn those into png images. Moreover, latex has the xr package, which allows us to reference labels from other documents. Lastly, the "ref{}" command is valid inside math-mode. So we have all the tools we need, but there is one slight problem. In order to use the xr latex package, we need to include the "externaldocument" command in the header of the document.

The solution

Now here's the fun part. When Doxygen renders all of the equations, it does so by generating a single latex source file called "_formulas.tex". We don't have explicit access to modify the preamble of that source file, but we are allowed to add optional packages to the list of what is included. We do that by modifying the "EXTRA_PACKAGES" line of the doxyfile. For instance, if we edit the doxyfile like this:

…
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
# packages that should be included in the LaTeX output.

EXTRA_PACKAGES = amsmath xr amsfonts
…

then when doxygen generates _formulas.tex it will include in the preamble a list of includes like this

    usepackage{amsmath}
    usepackage{xr}
    usepackage{amsfonts}

Note that Doxygen tokenizes the list of packages (parses it) at whitespace, and then takes each token and wraps it with "usepackage{}", inserting it into the header. We can hijack this method of input by making EXTRA_PACKAGES variable like this

…
EXTRA_PACKAGES = amsmath xr}externaldocument[paper-]{dummy}% amsfonts
…

Then the preamble of _formulas.tex will look like this

    usepackage{amsmath}
    usepackage{amsfonts}
    usepackage{xr}externaldocument[paper-]{dummy}%}
    usepackage{hyperref}

Note how we use a comment character (percent) to comment out the closing bracket that doxygen put's around our 'package'. Now we have an extra command in our preamble. If you haven't looked up the xr documentation yet, this command means to look for a file called "dummy.aux" generated by latex. The package extracts all the labels from that file and appends "paper-" to the front of the label names. Now we can change our code documentation to look like this:

/**
 *  file       CTheoreticalModel.h
 *  author     Joe Author (jauthor@institute.edu)
 *  date       Apr 17, 2010
 *  brief      Definition file for CTheoreticalModel class
 */

#ifndef CTHEORETICALMODEL_H_
#define CTHEORETICALMODEL_H_


/**
 *  brief  Theoretical Model derived in section f$ref{paper-sec:Model}f$,
 *          page f$pageref{paper-sec:Model}f$
 *
 *  This is a detailed description of the model
 */
class CTheoreticalModel
{
    private:
        double    m_alpha;    ///< [parameter] defined in equation f$ref{paper-eqn:alphaDef}f$
        double    m_beta;     ///< [parameter] defined in equation f$ref{paper-eqn:betaDef}f$

    public:
        /**
         *  brief      Construct a new model using the given parameters
         *  param[in]  alpha   [parameter] defined in equation
         *                      f$ref{paper-eqn:alphaDef}f$
         *  param[in]  beta    [parameter] defined in equation
         *                      f$ref{paper-eqn:betaDef}f$
         */
        CTheoreticalModel( double alpha, double beta );


        /**
         *  brief      calculates [some property] by implementing algorithm
         *              f$ref{paper-alg:SomeAlgorithm}f$ on page
         *              f$pageref{paper-alg:SomeAlgorithm}f$
         *  return     [some property]
         */
        double algorithmA();


        /**
         *  brief      updates the model by [some parameter] according to the
         *              dynamics of equation f$ref{paper-eqn:SomeEquation}f$
         *              on page f$pageref{paper-eqn:SomeEquation}f$
         *  param[in]  gamma   [parameter] defined in equation
         *                      f$ref{paper-eqn:gammaDef}f$
         */
        void equationB( double gamma );


        /**
         *  brief      tests [some parameter] against the model; implements
         *              condition f$ref{paper-eqn:SomeCondition}f$
         *  param[in]  theta   [some parameter] defined by equation
         *                      f$ref{paper-eqn:thetaDef}f$
         */
        bool testC( double theta );
};

#endif /* CTHEORETICALMODEL_H_ */

Now all we have to do is dump dummy.aux (generated when we build the paper using latex) into the html directory where doxygen is going to build _formulas.tex and then when we make the documentation it looks like this:

Sure, all the references are images… which isn't particularly great, but it's a lot better than having to go in and change the labels every time we make a change to the referenced document. Whenever writing a code and a referenced document are done in parallel, this could be quite a handy trick. If you want the html document to look a little more professional, add a package that will set the font to the same as the font set by your doxygen CSS stylesheet.

If you want to play around with the files used in this post, pick them up here: dummy.7z. Create the latex document with the following command.

latex dummy.tex

Then copy dummy.aux into the html directory.

cp dummy.aux html/

Then run doxygen

doxygen doxyfile

Instanciate Objects of Unknown Type from Their Parent Interface

Josh Bialkowski — Fri, 14 Aug 2009 19:13:36 GMT

This is based on my previous two posts on Static Interfaces in C++ and Keep Track of and Enumerate All Sub-classes of a Particular Interface. The idea is that I want my code to be extensible in the feature without requiring any re-writing of the current code base. The code base operates on generic objects via their interfaces, so as long as newly-coded classes properly extend those interfaces, the program should know how to handle them. The problem is, how can we write the program in such a manner that a user interface can enumerate available options for implementations of a particular interface, and how can we instantiate those objects?

In Keep Track of and Enumerate All Sub-classes of a Particular Interface I showed how to maintain a registry of classes deriving from a given interface, which handles the first problem, but there is a limitation in that all of these classes must provide a factory method that takes no parameters (void input). I decided that, for my project, this was not acceptable and I needed a way to define the creation parameters as part of the factory methods, whereas the creation parameters may be different for particular interfaces.

In Static Interfaces in C++ I showed how we can enforce the requirement of a static method in derived classes with a particular signature using a template interface.

In this post I will combine the two so that we can create a registry of classes that inherit from a particular interface, and provide a static factory method for creating objects of that interface, using a particular creation method signature unique to that interface. The registry will pair class names with function pointers that match the specific signature of the interface the class is being registered for.

Disclaimer: I do not claim this is the "best" way to handle this issue. This is just what I came up with. It happens to be pretty involved and overly indirect, which means it's probably bad design. It is, however, an extremely interesting exercise in generic programming.

Prequil: the code will require these later so there they are:

    /**
     *  file          RegistryTest.cpp
     *  date:      Aug 14, 2009
     *  brief:
     *
     *  detail:
     */


    #include 
    #include 
    #include 
    #include 

    using namespace std;

Ok, so lets begin. First let's define a couple of interfaces that we're interested in.

    class InterfaceA{};
    class InterfaceB{};
    class InterfaceC{};

Now we create a template class whose sole purpose is to create a per-interface typedef of the function signature that is necessary for instantiating and object of that class. Is it really possible that all sub-objects can be instantiated with the same parameters? If that's the case, shouldn't they all be combined into a single class that just contains that information as private members? Probably, but in my case these parameters are more like a "bare minimum" for instantiation, and then many more parameters are set by the user. It makes sense to me, I promise. If it doesn't to you, you don't have to use this.

    template< typename InterfaceType >
    class Factory
    {
        public:
            typedef InterfaceType*(*Creator)(void);
    };

Creator is now a typedef that aliases a function pointer that takes no parameters. Wait, isn't that what we had before? Yes, but now we make a couple of template specializations to define the different signatures for our specific interfaces. These specializations would normally be in the file that contained the interface declaration.

    /// specializations can define other creators, this one requires an int
    template<> class Factory
    {
        public:
            typedef InterfaceB*(*Creator)(int);
    };

    /// specializations can define other creators, this one requires an int, a
    /// bool, and a char
    template<> class Factory
    {
        public:
            typedef InterfaceC*(*Creator)(int,bool,char);
    };

Cool. Now we create a static interface that enforces it's derivative classes to contain a static method called createNew which can be used to instantiate a new object of that interface. We can use the typedef we just created to make the function signature generic for this template (or specific to individual instantiations of it).

    template
    class IStaticFactory
    {
        public:
            IStaticFactory()
            {
                typename Factory::Creator check = ClassType::createNew;
                check = check;
            }
    };

Still following? Good. Now we define the registry class template, which maps the class name of a derived class to a function pointer with an interface- specific signature that serves as a static factory for objects of the derived class, returning a pointer to that object of the type of the interface. See my previous post for details on this class.

    template 
    class Registry
    {
        private:
            std::map< std::string, typename Factory::Creator > m_creatorMap;


            Registry(){}

        public:

            static Registry& getInstance();


            bool registerClass( const std::string& name,
                                 typename Factory::Creator creator );


            std::set  getClassNames();


            typename
            Factory::Creator
            Registry::getCreator(
                    std::string className );
    };



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


    template 
    Registry& Registry::getInstance()
    {
        static Registry    registry;
        return registry;
    }


    template 
    bool Registry::registerClass( const std::string& name,
                            typename Factory::Creator creator )
    {
        m_creatorMap[name] = creator;
        return true;
    }

    template 
    std::set  Registry::getClassNames()
    {
        std::set   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;
    }

    template 
    typename
    Factory::Creator
    Registry::getCreator(
            std::string className )
    {
        return m_creatorMap[className];
    }

The difference between this and the Registry in my previous post, is that this time the registry uses the generic Factory<InterfaceType>::Creator typedef to define the function pointer. This way, that pointer is forced to have the specific signature. Sweet!

Now lets write some derived classes of those interfaces.

    class   DerivedA : public InterfaceA,
                        public IStaticFactory
    {
        public:
            static InterfaceA*  createNew(){ return (InterfaceA*)1; }
    };


    RegisterWithInterface(DerivedA, InterfaceA);



    class   DerivedB : public InterfaceB,
                        public IStaticFactory
    {
        public:
            static InterfaceB*  createNew(int a){ return (InterfaceB*)2; }
    };


    RegisterWithInterface(DerivedB, InterfaceB);



    class   DerivedC : public InterfaceC,
                        public IStaticFactory
    {
        public:
            static InterfaceC*  createNew(int a, bool b, char c){ return (InterfaceC*)3; }
    };

    RegisterWithInterface(DerivedC, InterfaceC);

These classes are basically dummies, but inheriting from IStaticFactory… the compiler will enforce that they contain the static method createNew with the proper signature. Notice that InterfaceA uses the default template so the static factory in DerivedA takes no parameters, while InterfaceB and InterfaceC have specializations so the static factories in DerivedB and DerivedC have their respective parameters. Since this is just an example, the methods don't actually create new objects they just return pointers, but in reality this is where we would use new DerivedA(…) and so on.

Well that's it. Pretty cool huh? The compiler will enforce all this stuff for us so we can actually say to ourselves when we write new implementations months from now "If it compiles, it will be compatible."

Lastly, here's a little test case to run

    int main()
    {
        DerivedA    a;
        DerivedB    b;
        DerivedC    c;

        InterfaceA* pA;
        InterfaceB* pB;
        InterfaceC* pC;

        Factory::Creator makesObjectOfA =
                Registry::getInstance().getCreator("DerivedA");
        pA = (*makesObjectOfA)();

        Factory::Creator makesObjectOfB =
                Registry::getInstance().getCreator("DerivedB");
        pB = (*makesObjectOfB)(1);

        Factory::Creator makesObjectOfC =
                Registry::getInstance().getCreator("DerivedC");
        pC = (*makesObjectOfC)(1,false,'a');

        cout << "pA: " << pA << "n";
        cout << "pB: " << pB << "n";
        cout << "pC: " << pC << "n";

        return 0;
    }

Static Interfaces in C++

Josh Bialkowski — Thu, 13 Aug 2009 15:09:12 GMT

I remember looking around a few weeks ago for how to make a "static interface" in c++. Basically, I wanted a way to use the compiler to enforce that a class had certain static functions. Almost all of the internet resources I found basically said "Why would you ever want to do that; you don't really want to do that; you probably have bad design" and so on… continuously begging the question. Of course, they were right: the design was bad and that wasn't really what I wanted to do. Well, never the less, I still managed to think of a way to create a sort of static interface using a template class.

The strategy is to define a template class that uses the static methods of the template parameter class. That way, as long as the template is instantiated, the compiler will complain unless we have provided those static functions. We can ensure that the template is instantiated and enforce the inheritance idea by making the derived class extend from the template class we wrote to enforce those static methods.

Here is an example. We can create the static interface by declaring a class template that uses the functions we want to enforce as part of the interface.

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

By assigning T::foo and T::bar to function pointers, we are saying, implicitly, that whatever class is provided as a parameter to this template must have a static method called foo and a static method called bar and, furthermore, that those static methods must have
the same signature as the function pointers we stuff them into.

By putting this code inside the constructor of the class, we know that this method of the template will be instantiated, even if we don't explicitly use it later in the code, as long as we derive from this class somewhere. So then, the last question is, where can we derive from it?

Well, in the class that we want to inherit the interface of course!

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

The DerivedClass constructor implicitly calls the StaticInterface constructor, which assigns the function pointers fooCheck and barCheck to the address of the functions DerivedClass::foo and DerivedClass::bar. As a result, if we forget the bar function in the DerivedClass the compiler will choke with an error. g++ says the following:

src/poc/test/StaticInterfaceTest.cpp: In constructor
`StaticInterface::StaticInterface() [with T = DerivedClass]':  
src/poc/test/StaticInterfaceTest.cpp:41: instantiated from here  
src/poc/test/StaticInterfaceTest.cpp:20: error: `bar' is not a member of
`DerivedClass'

Pretty cool huh?

As a final note, please consider this "an interesting observation" and not necessarily a "great design choice". As I said, I decided against actually trying to utilize this idea in my project, and I urge you think carefully before about yours before trying to use it yourself.

Keep Track of and Enumerate All Sub-classes of a Particular Interface

Josh Bialkowski — Tue, 11 Aug 2009 15:57:26 GMT

Here's another interesting C++ problem I encountered today. As is often the case, I found my answer by asking over at Stack Overflow. The question can be found here: http://stackoverflow.com/questions/1260954/how-can-i-keep-track- of-enumerate-all-classes-that-implement-an-interface

The issue was that I was writing a simulation program where I knew I would eventually want to simulate multiple different vehicles, with multiple different controllers, and multiple different estimators. Naturally, this led me to define an interface for each of these things, but the problem was that I only really want to implement a few subclasses of these interfaces now. In particular, I only have two vehicles, 2 controllers, and 1 estimator I'm interested in completing now, but I will probably want to implement at least 2 more vehicles, 2 more controllers, and 2 or 3 more estimators. And, finally, as far as the simulation is designed, I would like for the user to be able to select from a list of choices which vehicle, which controller, and which estimator to use. Therefore, I was looking for a clean way to keep a kind of registry of classes that implement each of these interfaces so that I wouldn't have to go back and change the interface code later when I implemented more sub-classes.

The solution that was accepted was to implement a registry class that maintains a mapping of class-names to constructors, and then update that mapping from within the class definition file from each of the implementing sub-classes using a static initializer. I went one step further and made the registry class generic (templated), and this is the result. There is an example code below.

File: CInterfaceRegistry.h

    /**
     *  file        CInterfaceRegistry.h
     *  date:      Aug 11, 2009
     *  brief:
     *
     *  detail:
     */

    #ifndef CINTERFACEREGISTRY_H_
    #define CINTERFACEREGISTRY_H_

    #include 
    #include 
    #include 
    #include 

    #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 
    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  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::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 
    CInterfaceRegistry& CInterfaceRegistry::getInstance()
    {
        static CInterfaceRegistry    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 
    bool CInterfaceRegistry::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 
    bool CInterfaceRegistry::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 
    std::set  CInterfaceRegistry::getClassNames()
    {
        std::set   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 
    InterfaceType*  CInterfaceRegistry::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

    /**
     *  file        CInterfaceRegistryTest.cpp
     *  date:      Aug 11, 2009
     *  brief:
     *
     *  detail:
     */

    #include "utility/CInterfaceRegistry.h"

    #include 
    #include 
    #include 

    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::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::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 classes =
                CInterfaceRegistry::getInstance().getClassNames();

        cout << "Currently registered subclasses of IDummyInterface: n";
        cout << "----------------------nn";

        set::iterator   str;
        for( str = classes.begin(); str != classes.end(); str++ )
            cout << *str << "n";

        cout << "nndonen";

        return 0;
    }

Note that the name returned by querying typeid() has a "9″ inserted in the front of it. The names used to identify a type in the type_info class are implementation specific, so it may or may not be a good idea to use them. In my case it will be fine.

Edit:
A better choice for the macro is to use something like this

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

which uses the class's name from the source code instead of the type_info name.

In-Place Matrix Transpose

Josh Bialkowski — Tue, 28 Jul 2009 11:07:16 GMT

I was looking around today for an algorithm for In-Place Matrix Transposition and didn't manage to find anything, so this is what I came up with. I'll analyze and document it fully later, but I just wanted to get it down.

It's wasteful in that it will repeat a lot of operations, especially for "thin" matrices (worst case: vector). But it will work, never-the-less. Worst case run time is at most $latex O(n^2)$ where $latex n$ is the size of the matrix $latex n = rows times columns$

Edit: No longer arbitrarily repeating cycles ( was leading to identity operation, duh! ).

    template 
    void CMatrix::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( data[k_new], temp );

                k       = k_new;
                i       = k%n;
                j       = k/n;
                k_new   = i*m + j;
            }while(k_new != k_start);

            swap( data[k_new], temp );
        }
    }

And the result: