// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use Caps;
use Element;
use ElementFactoryListType;
use Object;
use PadDirection;
use PluginFeature;
use Rank;
use StaticPadTemplate;
use URIType;
use ffi;
use glib;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// `ElementFactory` is used to create instances of elements. A
    /// GstElementFactory can be added to a `Plugin` as it is also a
    /// `PluginFeature`.
    ///
    /// Use the `ElementFactory::find` and `ElementFactory::create`
    /// functions to create element instances or use `ElementFactory::make` as a
    /// convenient shortcut.
    ///
    /// The following code example shows you how to create a GstFileSrc element.
    ///
    /// ## Using an element factory
    ///
    /// ```C
    ///   #include <gst/gst.h>
    ///
    ///   GstElement *src;
    ///   GstElementFactory *srcfactory;
    ///
    ///   gst_init (&argc, &argv);
    ///
    ///   srcfactory = gst_element_factory_find ("filesrc");
    ///   g_return_if_fail (srcfactory != NULL);
    ///   src = gst_element_factory_create (srcfactory, "src");
    ///   g_return_if_fail (src != NULL);
    ///   ...
    /// ```
    ///
    /// # Implements
    ///
    /// [`PluginFeatureExt`](trait.PluginFeatureExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct ElementFactory(Object<ffi::GstElementFactory, ffi::GstElementFactoryClass>): PluginFeature, Object;

    match fn {
        get_type => || ffi::gst_element_factory_get_type(),
    }
}

impl ElementFactory {
    /// Checks if the factory can sink all possible capabilities.
    /// ## `caps`
    /// the caps to check
    ///
    /// # Returns
    ///
    /// `true` if the caps are fully compatible.
    pub fn can_sink_all_caps(&self, caps: &Caps) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_can_sink_all_caps(self.to_glib_none().0, caps.to_glib_none().0))
        }
    }

    /// Checks if the factory can sink any possible capability.
    /// ## `caps`
    /// the caps to check
    ///
    /// # Returns
    ///
    /// `true` if the caps have a common subset.
    pub fn can_sink_any_caps(&self, caps: &Caps) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_can_sink_any_caps(self.to_glib_none().0, caps.to_glib_none().0))
        }
    }

    /// Checks if the factory can src all possible capabilities.
    /// ## `caps`
    /// the caps to check
    ///
    /// # Returns
    ///
    /// `true` if the caps are fully compatible.
    pub fn can_src_all_caps(&self, caps: &Caps) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_can_src_all_caps(self.to_glib_none().0, caps.to_glib_none().0))
        }
    }

    /// Checks if the factory can src any possible capability.
    /// ## `caps`
    /// the caps to check
    ///
    /// # Returns
    ///
    /// `true` if the caps have a common subset.
    pub fn can_src_any_caps(&self, caps: &Caps) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_can_src_any_caps(self.to_glib_none().0, caps.to_glib_none().0))
        }
    }

    /// Create a new element of the type defined by the given elementfactory.
    /// It will be given the name supplied, since all elements require a name as
    /// their first argument.
    /// ## `name`
    /// name of new element, or `None` to automatically create
    ///  a unique name
    ///
    /// # Returns
    ///
    /// new `Element` or `None`
    ///  if the element couldn't be created
    pub fn create<'a, P: Into<Option<&'a str>>>(&self, name: P) -> Option<Element> {
        let name = name.into();
        let name = name.to_glib_none();
        unsafe {
            from_glib_none(ffi::gst_element_factory_create(self.to_glib_none().0, name.0))
        }
    }

    /// Get the `glib::Type` for elements managed by this factory. The type can
    /// only be retrieved if the element factory is loaded, which can be
    /// assured with `PluginFeatureExt::load`.
    ///
    /// # Returns
    ///
    /// the `glib::Type` for elements managed by this factory or 0 if
    /// the factory is not loaded.
    pub fn get_element_type(&self) -> glib::types::Type {
        unsafe {
            from_glib(ffi::gst_element_factory_get_element_type(self.to_glib_none().0))
        }
    }

    /// Get the metadata on `self` with `key`.
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// the metadata with `key` on `self` or `None`
    /// when there was no metadata with the given `key`.
    pub fn get_metadata(&self, key: &str) -> Option<String> {
        unsafe {
            from_glib_none(ffi::gst_element_factory_get_metadata(self.to_glib_none().0, key.to_glib_none().0))
        }
    }

    /// Get the available keys for the metadata on `self`.
    ///
    /// # Returns
    ///
    ///
    /// a `None`-terminated array of key strings, or `None` when there is no
    /// metadata. Free with `g_strfreev` when no longer needed.
    pub fn get_metadata_keys(&self) -> Vec<String> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gst_element_factory_get_metadata_keys(self.to_glib_none().0))
        }
    }

    /// Gets the number of pad_templates in this factory.
    ///
    /// # Returns
    ///
    /// the number of pad_templates
    pub fn get_num_pad_templates(&self) -> u32 {
        unsafe {
            ffi::gst_element_factory_get_num_pad_templates(self.to_glib_none().0)
        }
    }

    /// Gets the `glib::List` of `StaticPadTemplate` for this factory.
    ///
    /// # Returns
    ///
    /// the
    ///  static pad templates
    pub fn get_static_pad_templates(&self) -> Vec<StaticPadTemplate> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::gst_element_factory_get_static_pad_templates(self.to_glib_none().0))
        }
    }

    /// Gets a `None`-terminated array of protocols this element supports or `None` if
    /// no protocols are supported. You may not change the contents of the returned
    /// array, as it is still owned by the element factory. Use `g_strdupv` to
    /// make a copy of the protocol string array if you need to.
    ///
    /// # Returns
    ///
    /// the supported protocols
    ///  or `None`
    pub fn get_uri_protocols(&self) -> Vec<String> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::gst_element_factory_get_uri_protocols(self.to_glib_none().0))
        }
    }

    /// Gets the type of URIs the element supports or `URIType::Unknown` if none.
    ///
    /// # Returns
    ///
    /// type of URIs this element supports
    pub fn get_uri_type(&self) -> URIType {
        unsafe {
            from_glib(ffi::gst_element_factory_get_uri_type(self.to_glib_none().0))
        }
    }

    /// Check if `self` implements the interface with name `interfacename`.
    /// ## `interfacename`
    /// an interface name
    ///
    /// # Returns
    ///
    /// `true` when `self` implement the interface.
    pub fn has_interface(&self, interfacename: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_has_interface(self.to_glib_none().0, interfacename.to_glib_none().0))
        }
    }

    /// Check if `self` is of the given types.
    /// ## `type_`
    /// a `ElementFactoryListType`
    ///
    /// # Returns
    ///
    /// `true` if `self` is of `type_`.
    pub fn list_is_type(&self, type_: ElementFactoryListType) -> bool {
        unsafe {
            from_glib(ffi::gst_element_factory_list_is_type(self.to_glib_none().0, type_))
        }
    }

    /// Search for an element factory of the given name. Refs the returned
    /// element factory; caller is responsible for unreffing.
    /// ## `name`
    /// name of factory to find
    ///
    /// # Returns
    ///
    /// `ElementFactory` if found,
    /// `None` otherwise
    pub fn find(name: &str) -> Option<ElementFactory> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_element_factory_find(name.to_glib_none().0))
        }
    }

    /// Filter out all the elementfactories in `list` that can handle `caps` in
    /// the given direction.
    ///
    /// If `subsetonly` is `true`, then only the elements whose pads templates
    /// are a complete superset of `caps` will be returned. Else any element
    /// whose pad templates caps can intersect with `caps` will be returned.
    /// ## `list`
    /// a `glib::List` of
    ///  `ElementFactory` to filter
    /// ## `caps`
    /// a `Caps`
    /// ## `direction`
    /// a `PadDirection` to filter on
    /// ## `subsetonly`
    /// whether to filter on caps subsets or not.
    ///
    /// # Returns
    ///
    /// a `glib::List` of
    ///  `ElementFactory` elements that match the given requisites.
    ///  Use `PluginFeature::list_free` after usage.
    pub fn list_filter(list: &[ElementFactory], caps: &Caps, direction: PadDirection, subsetonly: bool) -> Vec<ElementFactory> {
        assert_initialized_main_thread!();
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gst_element_factory_list_filter(list.to_glib_none().0, caps.to_glib_none().0, direction.to_glib(), subsetonly.to_glib()))
        }
    }

    /// Get a list of factories that match the given `type_`. Only elements
    /// with a rank greater or equal to `minrank` will be returned.
    /// The list of factories is returned by decreasing rank.
    /// ## `type_`
    /// a `ElementFactoryListType`
    /// ## `minrank`
    /// Minimum rank
    ///
    /// # Returns
    ///
    /// a `glib::List` of
    ///  `ElementFactory` elements. Use `PluginFeature::list_free` after
    ///  usage.
    pub fn list_get_elements(type_: ElementFactoryListType, minrank: Rank) -> Vec<ElementFactory> {
        assert_initialized_main_thread!();
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gst_element_factory_list_get_elements(type_, minrank.to_glib()))
        }
    }

    /// Create a new element of the type defined by the given element factory.
    /// If name is `None`, then the element will receive a guaranteed unique name,
    /// consisting of the element factory name and a number.
    /// If name is given, it will be given the name supplied.
    /// ## `factoryname`
    /// a named factory to instantiate
    /// ## `name`
    /// name of new element, or `None` to automatically create
    ///  a unique name
    ///
    /// # Returns
    ///
    /// new `Element` or `None`
    /// if unable to create element
    pub fn make<'a, P: Into<Option<&'a str>>>(factoryname: &str, name: P) -> Option<Element> {
        assert_initialized_main_thread!();
        let name = name.into();
        let name = name.to_glib_none();
        unsafe {
            from_glib_none(ffi::gst_element_factory_make(factoryname.to_glib_none().0, name.0))
        }
    }
}

unsafe impl Send for ElementFactory {}
unsafe impl Sync for ElementFactory {}