:right-sidebar: True

UriParamsIter
===================================================================

.. currentmodule:: gi.repository.GLib


.. versionadded:: 2.66




.. class:: UriParamsIter(*args, **kwargs)
   :no-contents-entry:






:Constructors:

::

    UriParamsIter()





Methods
-------

.. rst-class:: interim-class

.. class:: UriParamsIter
   :no-index:


   .. method:: init(params: str, length: int, separators: str, flags: ~gi.repository.GLib.UriParamsFlags) -> None

      Initializes an attribute/value pair iterator.

      The iterator keeps pointers to the ``params`` and ``separators`` arguments, those
      variables must thus outlive the iterator and not be modified during the
      iteration.

      If :const:`~gi.repository.GLib.UriParamsFlags.WWW_FORM` is passed in ``flags``, ``+`` characters in the param
      string will be replaced with spaces in the output. For example, ``foo=bar+baz``
      will give attribute ``foo`` with value `bar baz`. This is commonly used on the
      web (the ``https`` and ``http`` schemes only), but is deprecated in favour of
      the equivalent of encoding spaces as ```%20```.

      Unlike with :func:`~gi.repository.GLib.Uri.parse_params`, :const:`~gi.repository.GLib.UriParamsFlags.CASE_INSENSITIVE` has no
      effect if passed to ``flags`` for :func:`~gi.repository.GLib.UriParamsIter.init`. The caller is
      responsible for doing their own case-insensitive comparisons.


      .. code-block:: C
         :dedent:

         GUriParamsIter iter;
         GError *error = NULL;
         gchar *unowned_attr, *unowned_value;
         
         g_uri_params_iter_init (&iter, "foo=bar&baz=bar&Foo=frob&baz=bar2", -1, "&", G_URI_PARAMS_NONE);
         while (g_uri_params_iter_next (&iter, &unowned_attr, &unowned_value, &error))
           {
             g_autofree gchar *attr = g_steal_pointer (&unowned_attr);
             g_autofree gchar *value = g_steal_pointer (&unowned_value);
             // do something with attr and value; this code will be called 4 times
             // for the params string in this example: once with attr=foo and value=bar,
             // then with baz/bar, then Foo/frob, then baz/bar2.
           }
         if (error)
           // handle parsing error




      .. versionadded:: 2.66





      :param params: a ``%``-encoded string containing ``attribute=value``
         parameters


      :param length: the length of ``params``, or ``-1`` if it is nul-terminated


      :param separators: the separator byte character set between parameters. (usually
         ``&``, but sometimes ``;`` or both ``&;``). Note that this function works on
         bytes not characters, so it can't be used to delimit UTF-8 strings for
         anything but ASCII characters. You may pass an empty set, in which case
         no splitting will occur.


      :param flags: flags to modify the way the parameters are handled.





   .. method:: next() -> tuple[bool, str, str]

      Advances ``iter`` and retrieves the next attribute/value. :const:`False` is returned if
      an error has occurred (in which case ``error`` is set), or if the end of the
      iteration is reached (in which case ``attribute`` and ``value`` are set to :const:`None`
      and the iterator becomes invalid). If :const:`True` is returned,
      :func:`~gi.repository.GLib.UriParamsIter.next` may be called again to receive another
      attribute/value pair.

      Note that the same ``attribute`` may be returned multiple times, since URIs
      allow repeated attributes.



      .. versionadded:: 2.66


















Fields
------

.. rst-class:: interim-class

.. class:: UriParamsIter
   :no-index:
   

   .. attribute:: dummy0

      






   .. attribute:: dummy1

      






   .. attribute:: dummy2

      






   .. attribute:: dummy3