The visualization can be generated with the simple command:

gource --stop-at-end


To save the visualization in a video file, just execute(on linux):

gource --stop-at-end --output-ppm-stream - | ffmpeg -y -b 3000K -r 60 -f image2pipe -vcodec ppm -i - -vcodec mpeg4 gource.avi


In the end I decided to implement my own signals. The goal was the ease of use of the Qt signals with the speed and native C++ implementation as in libsigc++. Since I already use FastDelegate through out my code, there was no need for implementing a delegate mechanism. The only thing that had to be done was the signals themself. The signal functionality can be divided into two categories. Emitting the signals and connecting signal handlers. The first part is pretty obvious. I have a separate template signal class depending on the number of arguments. For now I implemented signals for methods/functions with 0 up to 3 arguments(if I need a signal taking more arguments it’s pretty much copy+paste).

The second type of functionality, connecting handlers, is a little more complicated. The most important thing is that when the instance of the object connected to the given signal gets destroyed, the signal should remove the callback from it’s list of handlers. For this, C++ has a killer feature: destructors. The simplest approach, used in libsigc++, is to create a connection object that will disconnect the callback from the signal when it gets destroyed. As I stated earlier I don’t like the need to have to manage those connections manually. The solution of course is a base class(again this approach is used in libsigc++), which will manage all the connections of the derived class. The problem arises when you have a class that already derives from another class. You could use virtual inheritance but this is what I would like to avoid at all cost.

My solution was to implement SignalConnector class that would manage all connections. Is is something like sigc::trackable, but you don’t need to derive from it, you can have it as a member in the handler class. There is also a interface ISignalHandler that has one abstract method signal_connector() which returns the reference to the objects SignalConnector. As a cherry on top, I implemented simple SignalsAwareObject base class which in turn implements ISignalHandler. The signals can be connected directly using the SignalConnector, or one of the helper template methods implemented in ISignalHandler. This way there are 3 options when it comes to deciding how the class will handle signals:

• Manually using SignalConnector class – most troublesome choice and offers no benefits.
• Implement ISignalHandler interface – When the class can’t derive from SignalsAwareObject. This gives the access to all of the helper methods defined in ISignalHandler, but still the class have to have it’s own SignalConnector and return it through signal_connector() method.
• Derive from the SignalsAwareObject – The best choice if applicable. No connection management required.

Here is a full example of usage(all 3 methods are shown):

#define _B(METHOD) fastdelegate::bind(&METHOD, this)

void foo(int val){
  std::cout << "foo(" << val << ")" << std::endl;
}

struct Test1{
    Test1()           {    }
    virtual ~Test1()  {    }

    void connect(Signal &signal){
      m_connector.connect(signal, _B(Test1::some_callback) );
    }

    void some_callback(int val){
      std::cout << "Test1::some_callback(" << val << ")" << std::endl;
    }
  private:
    SignalConnector m_connector;
};

struct Test2: public ISignalHandler{
    Test2()           {    }
    virtual ~Test2()  {    }

    void some_callback(int val){
      std::cout << "Test2::some_callback(" << val << ")" << std::endl;
    }

    const SignalConnector& signal_connector() const{ return m_connector; }
    SignalConnector m_connector;
};

struct Test3: public SignalsAwareObject{
  Test3()           {    }
  virtual ~Test3()  {    }

  void callback(int val){
    std::cout << "Test2::some_callback(" << val << ")" << std::endl;
  }
};

void test_connections(){
  using namespace nstd;
  {
    Signal    OnEvent;
    connect(OnEvent, &foo);
    {
      Test1 t1;
      Test2 t2;
      Test3 t3;
      connect(OnEvent, &t2, &Test2::some_callback);
      connect(OnEvent, &t3, &Test3::callback);
      t1.connect(OnEvent;);
      OnEvent(1);
    }
    OnEvent(2);
  }

  {
    Test1 t1;
    Test2 t2;
    Test3 t3;
    {
      Signal  OnEvent;
      connect(OnEvent, &t2, &Test2::some_callback);
      connect(OnEvent, &t3, &Test3::callback);
      t1.connect(OnEvent);
      OnEvent(3);
    }
  }
}

for(iterator it=begin(); it!=end(); ++it){
  if( it->key()==key ){
    // do something.
  }
}

I know there is std::find but it uses operator== so if I have one for my class I would have to create a temporary object to compare to or overload the operator for the given type. The first approach is useless in most cases, and the second one is more or less also useless since i can have 2 getters returning the same type and the operator== would work only for one of them.

On the other hand, there is std::find_if function which takes a predicate as a last argument and returns the object that satisfies predicate(obj)==true. This allows for a per vector/object customization of the search. The downside is that I would have to write a predicate for each vector type. I can have multiple predicates per class for different search conditions.

I found the solution to be quite simple. I implemented a predicate class for use with std::find_if that takes the getter address and the desired value and uses this getter for comparison. This way I have a little piece of code that allows me to search through every container using specific criterion(the given getter).

Here is the example usage:

// Sample structure
struct TT{
  TT(int _key, const std::string &_value) :key(_key), value(_value){}
  int id() const                          { return key;             }

  int           key;
  std::string   value;
};
typedef std::vector<TT>  Vector;

// And the searching(for an element with id()==10)
Vector::iterator it=std::find_if( v.begin(),
                                  v.end(),
                                  nstd::make_cmp(&TT::id, 10) );
if( it!=v.end() ) std::cout << "found: " << it->value << std::endl;
else              std::cout << "not found\n";

and here’s the predicate along with make_cmp() function for easier usage(without the copy constructor and assignment operator for clarity):

namespace nstd{
  template<class Owner, class KeyType, class RetType>
  struct CmpGetter{
      typedef RetType (Owner::*Getter)() const;

      CmpGetter(Getter getter, KeyType key)
      :m_getter(getter), m_key(key){
      }
      bool operator()(const Owner &obj){
        if( (obj.*m_getter)() == m_key )
          return true;
        return
          false;
      }

    private:
      Getter    m_getter;
      KeyType   m_key;
  };

  template<class Owner, class KeyType, class RetType>
  CmpGetter<Owner, KeyType, RetType>
  make_cmp( RetType (Owner::*getter)() const, KeyType key ){
    return CmpGetter<Owner, KeyType, RetType>(getter, key);
  }
}

This approach can be easily converted so it uses member value instead of accessor, but in my code 99% of the time all of the members are private/protected and access to them is wrapped in accessors so I don’t need the code to compare members.

As for the blog content, I will be posting my thought’s and ideas about coding here. Probably it’ll be mostly about game development since this is my area of interest, but I’m not locking my self on one subject. There won’t be any photos(except for screens ), love stories etc. If you’re after one, I’m sorry to disappoint

So here it is, I hope you’ll find something useful here.