// Generated by gtkmmproc -- DO NOT MODIFY!


#include <gstreamermm/multifdsink.h>
#include <gstreamermm/private/multifdsink_p.h>

// Generated by generate_plugin_gmmproc_file. Don't edit this file.


struct _GstMultiFdSinkClass
{
  GstBaseSinkClass parent_class;
  void (*add) (GstMultiFdSink* element, gint arg0);
  void (*add_full) (GstMultiFdSink* element, gint arg0, GstSyncMethod arg1, GstTCPUnitType arg2, guint64 arg3, GstTCPUnitType arg4, guint64 arg5);
  void (*remove) (GstMultiFdSink* element, gint arg0);
  void (*remove_flush) (GstMultiFdSink* element, gint arg0);
  void (*clear) (GstMultiFdSink* element);
  GValueArray* (*get_stats) (GstMultiFdSink* element, gint arg0);
  void (*client_added) (GstMultiFdSink* element, gint arg0);
  void (*client_removed) (GstMultiFdSink* element, gint arg0, GstClientStatus arg1);
  void (*client_fd_removed) (GstMultiFdSink* element, gint arg0);
};

extern "C"
{

static GType gst_fd_set_mode_get_type()
{
  static GType const type = g_type_from_name("GstFDSetMode");
  return type;
}

static GType gst_tcp_unit_type_get_type()
{
  static GType const type = g_type_from_name("GstTCPUnitType");
  return type;
}

static GType gst_recover_policy_get_type()
{
  static GType const type = g_type_from_name("GstRecoverPolicy");
  return type;
}

static GType gst_sync_method_get_type()
{
  static GType const type = g_type_from_name("GstSyncMethod");
  return type;
}

static GType gst_client_status_get_type()
{
  static GType const type = g_type_from_name("GstClientStatus");
  return type;
}

GType gst_multi_fd_sink_get_type()
{
  static GType type = 0;
  GstElementFactory* factory = 0;
  GstPluginFeature* feature = 0;

  if(!type)
  {
    factory = gst_element_factory_find("multifdsink");
    // Make sure that the feature is actually loaded:
    if(factory)
    {
      feature =
        gst_plugin_feature_load(GST_PLUGIN_FEATURE(factory));

      g_object_unref(factory);
      factory = GST_ELEMENT_FACTORY(feature);
      type = gst_element_factory_get_element_type(factory);
      g_object_unref(factory);
    }
  }

  return type;
}

} // extern "C"

namespace Gst
{

MultiFdSink::MultiFdSink()
: // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  Gst::BaseSink(Glib::ConstructParams(multifdsink_class_.init(), "name",static_cast<char*>(0), static_cast<char*>(0)))
{}

MultiFdSink::MultiFdSink(const Glib::ustring& name)
: // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  Gst::BaseSink(Glib::ConstructParams(multifdsink_class_.init(), "name",name.c_str(), static_cast<char*>(0)))
{}

void MultiFdSink::add(int arg0)
{
  g_signal_emit_by_name(gobj(), "add", arg0, static_cast<void*>(0));
}

void MultiFdSink::add_full(int arg0, Gst::SyncMethod arg1, Gst::TCPUnitType arg2, guint64 arg3, Gst::TCPUnitType arg4, guint64 arg5)
{
  g_signal_emit_by_name(gobj(), "add-full", arg0, ((GstSyncMethod)(arg1)), ((GstTCPUnitType)(arg2)), arg3, ((GstTCPUnitType)(arg4)), arg5, static_cast<void*>(0));
}

void MultiFdSink::remove(int arg0)
{
  g_signal_emit_by_name(gobj(), "remove", arg0, static_cast<void*>(0));
}

void MultiFdSink::remove_flush(int arg0)
{
  g_signal_emit_by_name(gobj(), "remove-flush", arg0, static_cast<void*>(0));
}

void MultiFdSink::clear()
{
  g_signal_emit_by_name(gobj(), "clear", static_cast<void*>(0));
}

Glib::ValueArray MultiFdSink::get_stats(int arg0)
{
  GValueArray* result;
  g_signal_emit_by_name(gobj(), "get-stats", arg0, &result, static_cast<void*>(0));
  return Glib::wrap(result);
}

}

namespace
{


static void MultiFdSink_signal_add_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_add_info =
{
  "add",
  (GCallback) &MultiFdSink_signal_add_callback,
  (GCallback) &MultiFdSink_signal_add_callback
};


static void MultiFdSink_signal_add_full_callback(GstMultiFdSink* self, gint p0,GstSyncMethod p1,GstTCPUnitType p2,guint64 p3,GstTCPUnitType p4,guint64 p5,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int,Gst::SyncMethod,Gst::TCPUnitType,guint64,Gst::TCPUnitType,guint64 > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
, ((Gst::SyncMethod)(p1))
, ((Gst::TCPUnitType)(p2))
, p3, ((Gst::TCPUnitType)(p4))
, p5);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_add_full_info =
{
  "add-full",
  (GCallback) &MultiFdSink_signal_add_full_callback,
  (GCallback) &MultiFdSink_signal_add_full_callback
};


static void MultiFdSink_signal_remove_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_remove_info =
{
  "remove",
  (GCallback) &MultiFdSink_signal_remove_callback,
  (GCallback) &MultiFdSink_signal_remove_callback
};


static void MultiFdSink_signal_remove_flush_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_remove_flush_info =
{
  "remove-flush",
  (GCallback) &MultiFdSink_signal_remove_flush_callback,
  (GCallback) &MultiFdSink_signal_remove_flush_callback
};


static const Glib::SignalProxyInfo MultiFdSink_signal_clear_info =
{
  "clear",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


static GValueArray* MultiFdSink_signal_get_stats_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< Glib::ValueArray,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        return ((*static_cast<SlotType*>(slot))(p0
)).gobj_copy();
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }

  typedef GValueArray* RType;
  return RType();
}

static GValueArray* MultiFdSink_signal_get_stats_notify_callback(GstMultiFdSink* self, gint p0, void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }

  typedef GValueArray* RType;
  return RType();
}

static const Glib::SignalProxyInfo MultiFdSink_signal_get_stats_info =
{
  "get-stats",
  (GCallback) &MultiFdSink_signal_get_stats_callback,
  (GCallback) &MultiFdSink_signal_get_stats_notify_callback
};


static void MultiFdSink_signal_client_added_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_client_added_info =
{
  "client-added",
  (GCallback) &MultiFdSink_signal_client_added_callback,
  (GCallback) &MultiFdSink_signal_client_added_callback
};


static void MultiFdSink_signal_client_removed_callback(GstMultiFdSink* self, gint p0,GstClientStatus p1,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int,Gst::ClientStatus > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
, ((Gst::ClientStatus)(p1))
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_client_removed_info =
{
  "client-removed",
  (GCallback) &MultiFdSink_signal_client_removed_callback,
  (GCallback) &MultiFdSink_signal_client_removed_callback
};


static void MultiFdSink_signal_client_fd_removed_callback(GstMultiFdSink* self, gint p0,void* data)
{
  using namespace Gst;
  typedef sigc::slot< void,int > SlotType;

  // Do not try to call a signal on a disassociated wrapper.
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  {
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    try
    {
    #endif //GLIBMM_EXCEPTIONS_ENABLED
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
    #endif //GLIBMM_EXCEPTIONS_ENABLED
  }
}

static const Glib::SignalProxyInfo MultiFdSink_signal_client_fd_removed_info =
{
  "client-fd-removed",
  (GCallback) &MultiFdSink_signal_client_fd_removed_callback,
  (GCallback) &MultiFdSink_signal_client_fd_removed_callback
};


} // anonymous namespace

// static
GType Glib::Value<Gst::FDSetMode>::value_type()
{
  return gst_fd_set_mode_get_type();
}

// static
GType Glib::Value<Gst::TCPUnitType>::value_type()
{
  return gst_tcp_unit_type_get_type();
}

// static
GType Glib::Value<Gst::RecoverPolicy>::value_type()
{
  return gst_recover_policy_get_type();
}

// static
GType Glib::Value<Gst::SyncMethod>::value_type()
{
  return gst_sync_method_get_type();
}

// static
GType Glib::Value<Gst::ClientStatus>::value_type()
{
  return gst_client_status_get_type();
}


namespace Glib
{

Glib::RefPtr<Gst::MultiFdSink> wrap(GstMultiFdSink* object, bool take_copy)
{
  return Glib::RefPtr<Gst::MultiFdSink>( dynamic_cast<Gst::MultiFdSink*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Glib */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& MultiFdSink_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &MultiFdSink_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_multi_fd_sink_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void MultiFdSink_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


  klass->add = &add_callback;
  klass->add_full = &add_full_callback;
  klass->remove = &remove_callback;
  klass->remove_flush = &remove_flush_callback;
  klass->clear = &clear_callback;
  klass->get_stats = &get_stats_callback;
  klass->client_added = &client_added_callback;
  klass->client_removed = &client_removed_callback;
  klass->client_fd_removed = &client_fd_removed_callback;
}


void MultiFdSink_Class::add_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_add(p0
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->add)
    (*base->add)(self, p0);
}
void MultiFdSink_Class::add_full_callback(GstMultiFdSink* self, gint p0, GstSyncMethod p1, GstTCPUnitType p2, guint64 p3, GstTCPUnitType p4, guint64 p5)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_add_full(p0
, ((Gst::SyncMethod)(p1))
, ((Gst::TCPUnitType)(p2))
, p3, ((Gst::TCPUnitType)(p4))
, p5);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->add_full)
    (*base->add_full)(self, p0, p1, p2, p3, p4, p5);
}
void MultiFdSink_Class::remove_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_remove(p0
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->remove)
    (*base->remove)(self, p0);
}
void MultiFdSink_Class::remove_flush_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_remove_flush(p0
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->remove_flush)
    (*base->remove_flush)(self, p0);
}
void MultiFdSink_Class::clear_callback(GstMultiFdSink* self)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_clear();
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->clear)
    (*base->clear)(self);
}
GValueArray* MultiFdSink_Class::get_stats_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        return (obj->on_get_stats(p0
)).gobj_copy();
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->get_stats)
    return (*base->get_stats)(self, p0);

  typedef GValueArray* RType;
  return RType();
}
void MultiFdSink_Class::client_added_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_client_added(p0
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->client_added)
    (*base->client_added)(self, p0);
}
void MultiFdSink_Class::client_removed_callback(GstMultiFdSink* self, gint p0, GstClientStatus p1)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_client_removed(p0
, ((Gst::ClientStatus)(p1))
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->client_removed)
    (*base->client_removed)(self, p0, p1);
}
void MultiFdSink_Class::client_fd_removed_callback(GstMultiFdSink* self, gint p0)
{
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));

  // Non-gtkmmproc-generated custom classes implicitly call the default
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
  // generated classes can use this optimisation, which avoids the unnecessary
  // parameter conversions if there is no possibility of the virtual function
  // being overridden:
  if(obj_base && obj_base->is_derived_())
  {
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
    if(obj) // This can be NULL during destruction.
    {
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
      {
      #endif //GLIBMM_EXCEPTIONS_ENABLED
        // Call the virtual member method, which derived classes might override.
        obj->on_client_fd_removed(p0
);
        return;
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
      }
      catch(...)
      {
        Glib::exception_handlers_invoke();
      }
      #endif //GLIBMM_EXCEPTIONS_ENABLED
    }
  }
  
  BaseClassType *const base = static_cast<BaseClassType*>(
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
    );

  // Call the original underlying C function:
  if(base && base->client_fd_removed)
    (*base->client_fd_removed)(self, p0);
}


Glib::ObjectBase* MultiFdSink_Class::wrap_new(GObject* object)
{
  return new MultiFdSink((GstMultiFdSink*)object);
}


/* The implementation: */

GstMultiFdSink* MultiFdSink::gobj_copy()
{
  reference();
  return gobj();
}

MultiFdSink::MultiFdSink(const Glib::ConstructParams& construct_params)
:
  Gst::BaseSink(construct_params)
{

}

MultiFdSink::MultiFdSink(GstMultiFdSink* castitem)
:
  Gst::BaseSink((GstBaseSink*)(castitem))
{}


MultiFdSink::~MultiFdSink()
{}


MultiFdSink::CppClassType MultiFdSink::multifdsink_class_; // initialize static member

GType MultiFdSink::get_type()
{
  return multifdsink_class_.init().get_type();
}


GType MultiFdSink::get_base_type()
{
  return gst_multi_fd_sink_get_type();
}


Glib::RefPtr<MultiFdSink> MultiFdSink::create()
{
  return Glib::RefPtr<MultiFdSink>( new MultiFdSink() );
}
Glib::RefPtr<MultiFdSink> MultiFdSink::create(const Glib::ustring& name)
{
  return Glib::RefPtr<MultiFdSink>( new MultiFdSink(name) );
}


Glib::SignalProxy1< void,int > MultiFdSink::signal_add()
{
  return Glib::SignalProxy1< void,int >(this, &MultiFdSink_signal_add_info);
}


Glib::SignalProxy6< void,int,Gst::SyncMethod,Gst::TCPUnitType,guint64,Gst::TCPUnitType,guint64 > MultiFdSink::signal_add_full()
{
  return Glib::SignalProxy6< void,int,Gst::SyncMethod,Gst::TCPUnitType,guint64,Gst::TCPUnitType,guint64 >(this, &MultiFdSink_signal_add_full_info);
}


Glib::SignalProxy1< void,int > MultiFdSink::signal_remove()
{
  return Glib::SignalProxy1< void,int >(this, &MultiFdSink_signal_remove_info);
}


Glib::SignalProxy1< void,int > MultiFdSink::signal_remove_flush()
{
  return Glib::SignalProxy1< void,int >(this, &MultiFdSink_signal_remove_flush_info);
}


Glib::SignalProxy0< void > MultiFdSink::signal_clear()
{
  return Glib::SignalProxy0< void >(this, &MultiFdSink_signal_clear_info);
}


Glib::SignalProxy1< Glib::ValueArray,int > MultiFdSink::signal_get_stats()
{
  return Glib::SignalProxy1< Glib::ValueArray,int >(this, &MultiFdSink_signal_get_stats_info);
}


Glib::SignalProxy1< void,int > MultiFdSink::signal_client_added()
{
  return Glib::SignalProxy1< void,int >(this, &MultiFdSink_signal_client_added_info);
}


Glib::SignalProxy2< void,int,Gst::ClientStatus > MultiFdSink::signal_client_removed()
{
  return Glib::SignalProxy2< void,int,Gst::ClientStatus >(this, &MultiFdSink_signal_client_removed_info);
}


Glib::SignalProxy1< void,int > MultiFdSink::signal_client_fd_removed()
{
  return Glib::SignalProxy1< void,int >(this, &MultiFdSink_signal_client_fd_removed_info);
}


#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::TCPProtocol> MultiFdSink::property_protocol() 
{
  return Glib::PropertyProxy<Gst::TCPProtocol>(this, "protocol");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::TCPProtocol> MultiFdSink::property_protocol() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::TCPProtocol>(this, "protocol");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::FDSetMode> MultiFdSink::property_mode() 
{
  return Glib::PropertyProxy<Gst::FDSetMode>(this, "mode");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::FDSetMode> MultiFdSink::property_mode() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::FDSetMode>(this, "mode");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint> MultiFdSink::property_buffers_queued() const
{
  return Glib::PropertyProxy_ReadOnly<guint>(this, "buffers-queued");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::TCPUnitType> MultiFdSink::property_unit_type() 
{
  return Glib::PropertyProxy<Gst::TCPUnitType>(this, "unit-type");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::TCPUnitType> MultiFdSink::property_unit_type() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::TCPUnitType>(this, "unit-type");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<gint64> MultiFdSink::property_units_max() 
{
  return Glib::PropertyProxy<gint64>(this, "units-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<gint64> MultiFdSink::property_units_max() const
{
  return Glib::PropertyProxy_ReadOnly<gint64>(this, "units-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<gint64> MultiFdSink::property_units_soft_max() 
{
  return Glib::PropertyProxy<gint64>(this, "units-soft-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<gint64> MultiFdSink::property_units_soft_max() const
{
  return Glib::PropertyProxy_ReadOnly<gint64>(this, "units-soft-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<int> MultiFdSink::property_buffers_max() 
{
  return Glib::PropertyProxy<int>(this, "buffers-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<int> MultiFdSink::property_buffers_max() const
{
  return Glib::PropertyProxy_ReadOnly<int>(this, "buffers-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<int> MultiFdSink::property_buffers_soft_max() 
{
  return Glib::PropertyProxy<int>(this, "buffers-soft-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<int> MultiFdSink::property_buffers_soft_max() const
{
  return Glib::PropertyProxy_ReadOnly<int>(this, "buffers-soft-max");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<gint64> MultiFdSink::property_time_min() 
{
  return Glib::PropertyProxy<gint64>(this, "time-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<gint64> MultiFdSink::property_time_min() const
{
  return Glib::PropertyProxy_ReadOnly<gint64>(this, "time-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<int> MultiFdSink::property_bytes_min() 
{
  return Glib::PropertyProxy<int>(this, "bytes-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<int> MultiFdSink::property_bytes_min() const
{
  return Glib::PropertyProxy_ReadOnly<int>(this, "bytes-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<int> MultiFdSink::property_buffers_min() 
{
  return Glib::PropertyProxy<int>(this, "buffers-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<int> MultiFdSink::property_buffers_min() const
{
  return Glib::PropertyProxy_ReadOnly<int>(this, "buffers-min");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::RecoverPolicy> MultiFdSink::property_recover_policy() 
{
  return Glib::PropertyProxy<Gst::RecoverPolicy>(this, "recover-policy");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::RecoverPolicy> MultiFdSink::property_recover_policy() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::RecoverPolicy>(this, "recover-policy");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<guint64> MultiFdSink::property_timeout() 
{
  return Glib::PropertyProxy<guint64>(this, "timeout");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint64> MultiFdSink::property_timeout() const
{
  return Glib::PropertyProxy_ReadOnly<guint64>(this, "timeout");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::SyncMethod> MultiFdSink::property_sync_method() 
{
  return Glib::PropertyProxy<Gst::SyncMethod>(this, "sync-method");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::SyncMethod> MultiFdSink::property_sync_method() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::SyncMethod>(this, "sync-method");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint64> MultiFdSink::property_bytes_to_serve() const
{
  return Glib::PropertyProxy_ReadOnly<guint64>(this, "bytes-to-serve");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint64> MultiFdSink::property_bytes_served() const
{
  return Glib::PropertyProxy_ReadOnly<guint64>(this, "bytes-served");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<Gst::TCPUnitType> MultiFdSink::property_burst_unit() 
{
  return Glib::PropertyProxy<Gst::TCPUnitType>(this, "burst-unit");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<Gst::TCPUnitType> MultiFdSink::property_burst_unit() const
{
  return Glib::PropertyProxy_ReadOnly<Gst::TCPUnitType>(this, "burst-unit");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<guint64> MultiFdSink::property_burst_value() 
{
  return Glib::PropertyProxy<guint64>(this, "burst-value");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint64> MultiFdSink::property_burst_value() const
{
  return Glib::PropertyProxy_ReadOnly<guint64>(this, "burst-value");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<int> MultiFdSink::property_qos_dscp() 
{
  return Glib::PropertyProxy<int>(this, "qos-dscp");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<int> MultiFdSink::property_qos_dscp() const
{
  return Glib::PropertyProxy_ReadOnly<int>(this, "qos-dscp");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> MultiFdSink::property_handle_read() 
{
  return Glib::PropertyProxy<bool>(this, "handle-read");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> MultiFdSink::property_handle_read() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "handle-read");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> MultiFdSink::property_resend_streamheader() 
{
  return Glib::PropertyProxy<bool>(this, "resend-streamheader");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> MultiFdSink::property_resend_streamheader() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "resend-streamheader");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint> MultiFdSink::property_num_fds() const
{
  return Glib::PropertyProxy_ReadOnly<guint>(this, "num-fds");
}
#endif //GLIBMM_PROPERTIES_ENABLED


void Gst::MultiFdSink::on_add(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->add)
    (*base->add)(gobj(),arg0);
}
void Gst::MultiFdSink::on_add_full(int arg0, Gst::SyncMethod arg1, Gst::TCPUnitType arg2, guint64 arg3, Gst::TCPUnitType arg4, guint64 arg5)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->add_full)
    (*base->add_full)(gobj(),arg0,((GstSyncMethod)(arg1)),((GstTCPUnitType)(arg2)),arg3,((GstTCPUnitType)(arg4)),arg5);
}
void Gst::MultiFdSink::on_remove(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->remove)
    (*base->remove)(gobj(),arg0);
}
void Gst::MultiFdSink::on_remove_flush(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->remove_flush)
    (*base->remove_flush)(gobj(),arg0);
}
void Gst::MultiFdSink::on_clear()
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->clear)
    (*base->clear)(gobj());
}
Glib::ValueArray Gst::MultiFdSink::on_get_stats(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->get_stats)
    return Glib::wrap((*base->get_stats)(gobj(),arg0));

  typedef Glib::ValueArray RType;
  return RType();
}
void Gst::MultiFdSink::on_client_added(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->client_added)
    (*base->client_added)(gobj(),arg0);
}
void Gst::MultiFdSink::on_client_removed(int arg0, Gst::ClientStatus arg1)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->client_removed)
    (*base->client_removed)(gobj(),arg0,((GstClientStatus)(arg1)));
}
void Gst::MultiFdSink::on_client_fd_removed(int arg0)
{
  BaseClassType *const base = static_cast<BaseClassType*>(
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
  );

  if(base && base->client_fd_removed)
    (*base->client_fd_removed)(gobj(),arg0);
}


} // namespace Gst


