// Generated by gtkmmproc -- DO NOT MODIFY!


#include <glibmm.h>

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


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


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_gstreamermm_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);

      // Register the new type with wrapping system
      Glib::wrap_register(type, &Gst::MultiFdSink_Class::wrap_new);
    }
  }

  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 Glib
{

Glib::RefPtr<Gst::MultiFdSink> wrap(GstMultiFdSink* object, bool take_copy)
{
  static bool registered_wrap_new = false;
  if(!registered_wrap_new)
  {
    // Call get *_get_type() function which does the registration.
    gst_multi_fd_sink_gstreamermm_get_type();
    registered_wrap_new = true;
  }

  return Glib::RefPtr<Gst::MultiFdSink>( dynamic_cast<Gst::MultiFdSink*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
}

}

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 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_gstreamermm_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);


}


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_gstreamermm_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


} // namespace Gst


