## Interface definition prerequisites

To specify that an interface requires the presence of other interfaces when implemented, GObject introduces the concept of prerequisites: it is possible to associate a list of prerequisite interfaces to an interface. For example, if object A wishes to implement interface I1, and if interface I1 has a prerequisite on interface I2, A has to implement both I1 and I2.

The mechanism described above is, in practice, very similar to Java's interface I1 extends interface I2. The example below shows the GObject equivalent:

      type = g_type_register_static (G_TYPE_INTERFACE, "MamanIbar", &info, 0);
      /* Make the MamanIbar interface require MamanIbaz interface. */
      g_type_interface_add_prerequisite (type, MAMAN_TYPE_IBAZ);

The code shown above adds the MamanIbaz interface to the list of prerequisites of MamanIbar while the code below shows how an implementation can implement both interfaces and register their implementations:

    static void ibar_do_another_action (MamanBar *self)
    {
      g_print ("Bar implementation of IBar interface Another Action: 0x%x.\n", self->instance_member);
    }

    static void
    ibar_interface_init (gpointer   g_iface,
                         gpointer   iface_data)
    {
      MamanIbarInterface *iface = (MamanIbarInterface *)g_iface;
      iface->do_another_action = (void (*) (MamanIbar *self))ibar_do_another_action;
    }

    static void ibaz_do_action (MamanBar *self)
    {
      g_print ("Bar implementation of IBaz interface Action: 0x%x.\n", self->instance_member);
    }

    static void
    ibaz_interface_init (gpointer   g_iface,
                        gpointer   iface_data)
    {
      MamanIbazInterface *iface = (MamanIbazInterface *)g_iface;
      iface->do_action = (void (*) (MamanIbaz *self))ibaz_do_action;
    }

    static void
    bar_instance_init (GTypeInstance   *instance,
                       gpointer         g_class)
    {
      MamanBar *self = (MamanBar *)instance;
      self->instance_member = 0x666;
    }

    GType
    maman_bar_get_type (void)
    {
      static GType type = 0;
      if (type == 0) {
        static const GTypeInfo info = {
          sizeof (MamanBarClass),
          NULL,   /* base_init */
          NULL,   /* base_finalize */
          NULL,   /* class_init */
          NULL,   /* class_finalize */
          NULL,   /* class_data */
          sizeof (MamanBar),
          0,      /* n_preallocs */
          bar_instance_init    /* instance_init */
        };
        static const GInterfaceInfo ibar_info = {
          (GInterfaceInitFunc) ibar_interface_init,   /* interface_init */
          NULL,                                       /* interface_finalize */
          NULL                                        /* interface_data */
        };
        static const GInterfaceInfo ibaz_info = {
          (GInterfaceInitFunc) ibaz_interface_init,   /* interface_init */
          NULL,                                       /* interface_finalize */
          NULL                                        /* interface_data */
        };
        type = g_type_register_static (G_TYPE_OBJECT,
                                       "MamanBarType",
                                       &info, 0);
        g_type_add_interface_static (type,
                                     MAMAN_TYPE_IBAZ,
                                     &ibaz_info);
        g_type_add_interface_static (type,
                                     MAMAN_TYPE_IBAR,
                                     &ibar_info);
      }
      return type;
    }

It is very important to notice that the order in which interface implementations are added to the main object is not random: `g_type_add_interface_static` must be invoked first on the interfaces which have no prerequisites and then on the others.

Complete source code showing how to define the MamanIbar interface which requires MamanIbaz and how to implement the MamanIbar interface is located in `sample/interface/maman-ibar.{h|c}` and `sample/interface/maman-bar.{h|c}`.