libsig

Signal/Event handling lib for C/C++

ligsig is a signal/event library for C and C++ which allows to handling signals/events like observer pattern. Member functions also can be used as callbacks.

Each signal has a signal context which allows that signals can be used in their own context. Also the system signals such as SIGPIPE... can be observed in system context (sig_sys_ctx) ).

Predefined contexts:

// sig_attach/sig_detach/sig_fire functions
// use the default ctx if there is no specified one
const sig_context_t * sig_ctx_default();

// sistem signals can be observed by using this ctx
const sig_context_t * sig_ctx_sys();

Alloc and free custom contexts:

const sig_context_t * sig_ctx_new();
void sig_ctx_free(const sig_context_t * ctx);

####For C:#### The functions are overloaded by _s postfix (and c postfix for custom contexts):

/*
  For all (or full) declerations (especially for custom ctx)
  look at the sig.h header
 */

/* Observe a signal by signal name or id */
void sig_attach(int signal, sig_observer_cb_t cb);
void sig_attach_s(const char * signal, sig_observer_cb_t cb);

/* Stop observe a signal by signal name or id */
void sig_detach(int signal, sig_observer_cb_t cb);
void sig_detach_s(const char * signal, sig_observer_cb_t cb);

/* Fire a signal by signal name or id */
void sig_fire(int signal, void * object);
void sig_fire_s(const char * signal, void * object);

####For C++:####

/*
  For all (or full) declerations (especially for custom ctx)
  look at the sig.h header
 */

/* Observe a signal by signal name or id */
void sig_attach(int signal, sig_observer_cb_t cb);
void sig_attach(const char * signal, sig_observer_cb_t cb);

// For member functions
void sig_attach(int signal, sig_slot(T *, Func));
void sig_attach(const char * signal, sig_slot(T *, Func));

// -------------------------------------------------------

/* Stop observe a signal by signal name or id */
void sig_detach(int signal, sig_observer_cb_t cb);
void sig_detach(const char * signal, sig_observer_cb_t cb);

// For member functions
void sig_detach(int signal, sig_slot(T *, Func));
void sig_detach(const char * signal, sig_slot(T *, Func));

// Detach all observers from the object/instance
void sig_detach(void * observer);
void sig_detach(void * observer, const sig_context_t * ctx);

// -------------------------------------------------------

/* Fire a signal by signal name or id */
void sig_fire(int signal, void * object);
void sig_fire(const char * signal, void * object);

Signals also can be observed or can be fired by the following style for C++:

/* Observe a signal */
sig::attach[1234] << fn_callback1 ... ;
sig::attach["signal_name"] << fn_callback1 << fn_callback2 ...;

/* Stop observe */
sig::detach[1234] >> fn_callback1 ...;
sig::detach["signal_name"] >> fn_callback1 >> fn_callback2 ...;

/* Fire (trigger) a signal */
sig:fire["signal_name"] << (void *)"Signal object (void *)";

Build

Unix / Macintosh

$ sh autogen.sh
$ ./configure
$ make
$ [sudo] make install

Windows

$ msbuild libsig.vcxproj /p:Configuration=Release

###Sample###

#include <iostream>
#include <signal.h>
#include <sig.h>

#define CUSTOM_NTF1 123

class TestClass {
public:
  TestClass() {
    sig_attach(CUSTOM_NTF1,
               sig_slot(this, &TestClass::memberFn));

    sig_attach("custom_ntf2",
               sig_slot(this, &TestClass::memberFn));

    // Attach / Observe system signals
    sig_attach(SIGUSR1,
               sig_slot(this, &TestClass::memberFn),
               sig_ctx_sys());
  }

  void memberFn(const sig_signal_t sig) {

    // Do somethings...

    std::cout << "notification (TestClass): "
              << (const char *)sig.object
              << std::endl;
  }

  void stopObserveNtf1() {
    sig_detach(CUSTOM_NTF1,
               sig_slot(this, &TestClass::memberFn));
  }

  ~TestClass() {
    sig_detach(this);
  }
};

// non-member function
void do_somethings(const sig_signal_t signal) {
    std::cout << "notification (do_somethings): "
              << (const char *)signal.object
              << std::endl;
}

int main() {

  // Observe a signal/event
  sig_attach("signal-1", do_somethings);

  // Fire signal
  sig_fire("signal-1", (void *)"signal-1 object");


  // Test Member functions

  TestClass t1;

  sig_fire(CUSTOM_NTF1, (void *)"ntf 1 object");
  t1.stopObserveNtf1();
  sig_fire(CUSTOM_NTF1, (void *)"ntf 1 object");

  sig_fire("custom_ntf2", (void *)"ntf 2 object");

  raise(SIGUSR1);

  return 0;
}

Output:

notification (do_somethings): signal-1 object
notification (TestClass): ntf 1 object
notification (TestClass): ntf 2 object
notification (TestClass):