# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.


# Copyright (c) 2019-2021, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.



from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _NvRules
else:
    import _NvRules

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_SwigPyIterator

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _NvRules.SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        """
        return _NvRules.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        """
        return _NvRules.SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _NvRules.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""
        equal(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _NvRules.SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _NvRules.SwigPyIterator_copy(self)

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _NvRules.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _NvRules.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _NvRules.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _NvRules.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _NvRules.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _NvRules.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _NvRules.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _NvRules.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _NvRules.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _NvRules.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _NvRules:
_NvRules.SwigPyIterator_swigregister(SwigPyIterator)
class map_string_string(object):
    r"""Proxy of C++ std::map< std::string,std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(map_string_string self) -> SwigPyIterator"""
        return _NvRules.map_string_string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(map_string_string self) -> bool"""
        return _NvRules.map_string_string___nonzero__(self)

    def __bool__(self):
        r"""__bool__(map_string_string self) -> bool"""
        return _NvRules.map_string_string___bool__(self)

    def __len__(self):
        r"""__len__(map_string_string self) -> std::map< std::string,std::string >::size_type"""
        return _NvRules.map_string_string___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""
        __getitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string_has_key(self, key)

    def keys(self):
        r"""keys(map_string_string self) -> PyObject *"""
        return _NvRules.map_string_string_keys(self)

    def values(self):
        r"""values(map_string_string self) -> PyObject *"""
        return _NvRules.map_string_string_values(self)

    def items(self):
        r"""items(map_string_string self) -> PyObject *"""
        return _NvRules.map_string_string_items(self)

    def __contains__(self, key):
        r"""
        __contains__(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(map_string_string self) -> SwigPyIterator"""
        return _NvRules.map_string_string_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(map_string_string self) -> SwigPyIterator"""
        return _NvRules.map_string_string_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &

        __setitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)

        Parameters
        ----------
        key: std::map< std::string,std::string >::key_type const &
        x: std::map< std::string,std::string >::mapped_type const &

        """
        return _NvRules.map_string_string___setitem__(self, *args)

    def asdict(self):
        r"""asdict(map_string_string self) -> PyObject *"""
        return _NvRules.map_string_string_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(map_string_string self, std::less< std::string > const & other) -> map_string_string

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(map_string_string self) -> map_string_string
        __init__(map_string_string self, map_string_string other) -> map_string_string

        Parameters
        ----------
        other: std::map< std::string,std::string > const &

        """
        _NvRules.map_string_string_swiginit(self, _NvRules.new_map_string_string(*args))

    def empty(self):
        r"""empty(map_string_string self) -> bool"""
        return _NvRules.map_string_string_empty(self)

    def size(self):
        r"""size(map_string_string self) -> std::map< std::string,std::string >::size_type"""
        return _NvRules.map_string_string_size(self)

    def swap(self, v):
        r"""
        swap(map_string_string self, map_string_string v)

        Parameters
        ----------
        v: std::map< std::string,std::string > &

        """
        return _NvRules.map_string_string_swap(self, v)

    def begin(self):
        r"""begin(map_string_string self) -> std::map< std::string,std::string >::iterator"""
        return _NvRules.map_string_string_begin(self)

    def end(self):
        r"""end(map_string_string self) -> std::map< std::string,std::string >::iterator"""
        return _NvRules.map_string_string_end(self)

    def rbegin(self):
        r"""rbegin(map_string_string self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _NvRules.map_string_string_rbegin(self)

    def rend(self):
        r"""rend(map_string_string self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _NvRules.map_string_string_rend(self)

    def clear(self):
        r"""clear(map_string_string self)"""
        return _NvRules.map_string_string_clear(self)

    def get_allocator(self):
        r"""get_allocator(map_string_string self) -> std::map< std::string,std::string >::allocator_type"""
        return _NvRules.map_string_string_get_allocator(self)

    def count(self, x):
        r"""
        count(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string_count(self, x)

    def erase(self, *args):
        r"""
        erase(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::string >::key_type const &

        erase(map_string_string self, std::map< std::string,std::string >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,std::string >::iterator

        erase(map_string_string self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,std::string >::iterator
        last: std::map< std::string,std::string >::iterator

        """
        return _NvRules.map_string_string_erase(self, *args)

    def find(self, x):
        r"""
        find(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::string >::key_type const &

        """
        return _NvRules.map_string_string_upper_bound(self, x)
    __swig_destroy__ = _NvRules.delete_map_string_string

# Register map_string_string in _NvRules:
_NvRules.map_string_string_swigregister(map_string_string)
class map_string_double(object):
    r"""Proxy of C++ std::map< std::string,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(map_string_double self) -> SwigPyIterator"""
        return _NvRules.map_string_double_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(map_string_double self) -> bool"""
        return _NvRules.map_string_double___nonzero__(self)

    def __bool__(self):
        r"""__bool__(map_string_double self) -> bool"""
        return _NvRules.map_string_double___bool__(self)

    def __len__(self):
        r"""__len__(map_string_double self) -> std::map< std::string,double >::size_type"""
        return _NvRules.map_string_double___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""
        __getitem__(map_string_double self, std::map< std::string,double >::key_type const & key) -> std::map< std::string,double >::mapped_type const &

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(map_string_double self, std::map< std::string,double >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(map_string_double self, std::map< std::string,double >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double_has_key(self, key)

    def keys(self):
        r"""keys(map_string_double self) -> PyObject *"""
        return _NvRules.map_string_double_keys(self)

    def values(self):
        r"""values(map_string_double self) -> PyObject *"""
        return _NvRules.map_string_double_values(self)

    def items(self):
        r"""items(map_string_double self) -> PyObject *"""
        return _NvRules.map_string_double_items(self)

    def __contains__(self, key):
        r"""
        __contains__(map_string_double self, std::map< std::string,double >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(map_string_double self) -> SwigPyIterator"""
        return _NvRules.map_string_double_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(map_string_double self) -> SwigPyIterator"""
        return _NvRules.map_string_double_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(map_string_double self, std::map< std::string,double >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &

        __setitem__(map_string_double self, std::map< std::string,double >::key_type const & key, std::map< std::string,double >::mapped_type const & x)

        Parameters
        ----------
        key: std::map< std::string,double >::key_type const &
        x: std::map< std::string,double >::mapped_type const &

        """
        return _NvRules.map_string_double___setitem__(self, *args)

    def asdict(self):
        r"""asdict(map_string_double self) -> PyObject *"""
        return _NvRules.map_string_double_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(map_string_double self, std::less< std::string > const & other) -> map_string_double

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(map_string_double self) -> map_string_double
        __init__(map_string_double self, map_string_double other) -> map_string_double

        Parameters
        ----------
        other: std::map< std::string,double > const &

        """
        _NvRules.map_string_double_swiginit(self, _NvRules.new_map_string_double(*args))

    def empty(self):
        r"""empty(map_string_double self) -> bool"""
        return _NvRules.map_string_double_empty(self)

    def size(self):
        r"""size(map_string_double self) -> std::map< std::string,double >::size_type"""
        return _NvRules.map_string_double_size(self)

    def swap(self, v):
        r"""
        swap(map_string_double self, map_string_double v)

        Parameters
        ----------
        v: std::map< std::string,double > &

        """
        return _NvRules.map_string_double_swap(self, v)

    def begin(self):
        r"""begin(map_string_double self) -> std::map< std::string,double >::iterator"""
        return _NvRules.map_string_double_begin(self)

    def end(self):
        r"""end(map_string_double self) -> std::map< std::string,double >::iterator"""
        return _NvRules.map_string_double_end(self)

    def rbegin(self):
        r"""rbegin(map_string_double self) -> std::map< std::string,double >::reverse_iterator"""
        return _NvRules.map_string_double_rbegin(self)

    def rend(self):
        r"""rend(map_string_double self) -> std::map< std::string,double >::reverse_iterator"""
        return _NvRules.map_string_double_rend(self)

    def clear(self):
        r"""clear(map_string_double self)"""
        return _NvRules.map_string_double_clear(self)

    def get_allocator(self):
        r"""get_allocator(map_string_double self) -> std::map< std::string,double >::allocator_type"""
        return _NvRules.map_string_double_get_allocator(self)

    def count(self, x):
        r"""
        count(map_string_double self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type

        Parameters
        ----------
        x: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double_count(self, x)

    def erase(self, *args):
        r"""
        erase(map_string_double self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type

        Parameters
        ----------
        x: std::map< std::string,double >::key_type const &

        erase(map_string_double self, std::map< std::string,double >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,double >::iterator

        erase(map_string_double self, std::map< std::string,double >::iterator first, std::map< std::string,double >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,double >::iterator
        last: std::map< std::string,double >::iterator

        """
        return _NvRules.map_string_double_erase(self, *args)

    def find(self, x):
        r"""
        find(map_string_double self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator

        Parameters
        ----------
        x: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(map_string_double self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator

        Parameters
        ----------
        x: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(map_string_double self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator

        Parameters
        ----------
        x: std::map< std::string,double >::key_type const &

        """
        return _NvRules.map_string_double_upper_bound(self, x)
    __swig_destroy__ = _NvRules.delete_map_string_double

# Register map_string_double in _NvRules:
_NvRules.map_string_double_swigregister(map_string_double)
class set_string(object):
    r"""Proxy of C++ std::set< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(set_string self) -> SwigPyIterator"""
        return _NvRules.set_string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(set_string self) -> bool"""
        return _NvRules.set_string___nonzero__(self)

    def __bool__(self):
        r"""__bool__(set_string self) -> bool"""
        return _NvRules.set_string___bool__(self)

    def __len__(self):
        r"""__len__(set_string self) -> std::set< std::string >::size_type"""
        return _NvRules.set_string___len__(self)

    def append(self, x):
        r"""
        append(set_string self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _NvRules.set_string_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(set_string self, std::set< std::string >::value_type x) -> bool

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _NvRules.set_string___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(set_string self, std::set< std::string >::difference_type i) -> std::set< std::string >::value_type

        Parameters
        ----------
        i: std::set< std::string >::difference_type

        """
        return _NvRules.set_string___getitem__(self, i)

    def add(self, x):
        r"""
        add(set_string self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _NvRules.set_string_add(self, x)

    def discard(self, x):
        r"""
        discard(set_string self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _NvRules.set_string_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(set_string self, std::less< std::string > const & other) -> set_string

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(set_string self) -> set_string
        __init__(set_string self, set_string other) -> set_string

        Parameters
        ----------
        other: std::set< std::string > const &

        """
        _NvRules.set_string_swiginit(self, _NvRules.new_set_string(*args))

    def empty(self):
        r"""empty(set_string self) -> bool"""
        return _NvRules.set_string_empty(self)

    def size(self):
        r"""size(set_string self) -> std::set< std::string >::size_type"""
        return _NvRules.set_string_size(self)

    def clear(self):
        r"""clear(set_string self)"""
        return _NvRules.set_string_clear(self)

    def swap(self, v):
        r"""
        swap(set_string self, set_string v)

        Parameters
        ----------
        v: std::set< std::string > &

        """
        return _NvRules.set_string_swap(self, v)

    def count(self, x):
        r"""
        count(set_string self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _NvRules.set_string_count(self, x)

    def begin(self):
        r"""begin(set_string self) -> std::set< std::string >::iterator"""
        return _NvRules.set_string_begin(self)

    def end(self):
        r"""end(set_string self) -> std::set< std::string >::iterator"""
        return _NvRules.set_string_end(self)

    def rbegin(self):
        r"""rbegin(set_string self) -> std::set< std::string >::reverse_iterator"""
        return _NvRules.set_string_rbegin(self)

    def rend(self):
        r"""rend(set_string self) -> std::set< std::string >::reverse_iterator"""
        return _NvRules.set_string_rend(self)

    def erase(self, *args):
        r"""
        erase(set_string self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        erase(set_string self, std::set< std::string >::iterator pos)

        Parameters
        ----------
        pos: std::set< std::string >::iterator

        erase(set_string self, std::set< std::string >::iterator first, std::set< std::string >::iterator last)

        Parameters
        ----------
        first: std::set< std::string >::iterator
        last: std::set< std::string >::iterator

        """
        return _NvRules.set_string_erase(self, *args)

    def find(self, x):
        r"""
        find(set_string self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _NvRules.set_string_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(set_string self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _NvRules.set_string_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(set_string self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _NvRules.set_string_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(set_string self, std::set< std::string >::key_type const & x) -> std::pair< std::set< std::string >::iterator,std::set< std::string >::iterator >

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _NvRules.set_string_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(set_string self, std::set< std::string >::value_type const & __x) -> std::pair< std::set< std::string >::iterator,bool >

        Parameters
        ----------
        __x: std::set< std::string >::value_type const &

        """
        return _NvRules.set_string_insert(self, __x)
    __swig_destroy__ = _NvRules.delete_set_string

# Register set_string in _NvRules:
_NvRules.set_string_swigregister(set_string)
class set_ull(object):
    r"""Proxy of C++ std::set< unsigned long long > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(set_ull self) -> SwigPyIterator"""
        return _NvRules.set_ull_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(set_ull self) -> bool"""
        return _NvRules.set_ull___nonzero__(self)

    def __bool__(self):
        r"""__bool__(set_ull self) -> bool"""
        return _NvRules.set_ull___bool__(self)

    def __len__(self):
        r"""__len__(set_ull self) -> std::set< unsigned long long >::size_type"""
        return _NvRules.set_ull___len__(self)

    def append(self, x):
        r"""
        append(set_ull self, std::set< unsigned long long >::value_type x)

        Parameters
        ----------
        x: std::set< unsigned long long >::value_type

        """
        return _NvRules.set_ull_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(set_ull self, std::set< unsigned long long >::value_type x) -> bool

        Parameters
        ----------
        x: std::set< unsigned long long >::value_type

        """
        return _NvRules.set_ull___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(set_ull self, std::set< unsigned long long >::difference_type i) -> std::set< unsigned long long >::value_type

        Parameters
        ----------
        i: std::set< unsigned long long >::difference_type

        """
        return _NvRules.set_ull___getitem__(self, i)

    def add(self, x):
        r"""
        add(set_ull self, std::set< unsigned long long >::value_type x)

        Parameters
        ----------
        x: std::set< unsigned long long >::value_type

        """
        return _NvRules.set_ull_add(self, x)

    def discard(self, x):
        r"""
        discard(set_ull self, std::set< unsigned long long >::value_type x)

        Parameters
        ----------
        x: std::set< unsigned long long >::value_type

        """
        return _NvRules.set_ull_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(set_ull self, std::less< unsigned long long > const & other) -> set_ull

        Parameters
        ----------
        other: std::less< unsigned long long > const &

        __init__(set_ull self) -> set_ull
        __init__(set_ull self, set_ull other) -> set_ull

        Parameters
        ----------
        other: std::set< unsigned long long > const &

        """
        _NvRules.set_ull_swiginit(self, _NvRules.new_set_ull(*args))

    def empty(self):
        r"""empty(set_ull self) -> bool"""
        return _NvRules.set_ull_empty(self)

    def size(self):
        r"""size(set_ull self) -> std::set< unsigned long long >::size_type"""
        return _NvRules.set_ull_size(self)

    def clear(self):
        r"""clear(set_ull self)"""
        return _NvRules.set_ull_clear(self)

    def swap(self, v):
        r"""
        swap(set_ull self, set_ull v)

        Parameters
        ----------
        v: std::set< unsigned long long > &

        """
        return _NvRules.set_ull_swap(self, v)

    def count(self, x):
        r"""
        count(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::set< unsigned long long >::size_type

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        """
        return _NvRules.set_ull_count(self, x)

    def begin(self):
        r"""begin(set_ull self) -> std::set< unsigned long long >::iterator"""
        return _NvRules.set_ull_begin(self)

    def end(self):
        r"""end(set_ull self) -> std::set< unsigned long long >::iterator"""
        return _NvRules.set_ull_end(self)

    def rbegin(self):
        r"""rbegin(set_ull self) -> std::set< unsigned long long >::reverse_iterator"""
        return _NvRules.set_ull_rbegin(self)

    def rend(self):
        r"""rend(set_ull self) -> std::set< unsigned long long >::reverse_iterator"""
        return _NvRules.set_ull_rend(self)

    def erase(self, *args):
        r"""
        erase(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::set< unsigned long long >::size_type

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        erase(set_ull self, std::set< unsigned long long >::iterator pos)

        Parameters
        ----------
        pos: std::set< unsigned long long >::iterator

        erase(set_ull self, std::set< unsigned long long >::iterator first, std::set< unsigned long long >::iterator last)

        Parameters
        ----------
        first: std::set< unsigned long long >::iterator
        last: std::set< unsigned long long >::iterator

        """
        return _NvRules.set_ull_erase(self, *args)

    def find(self, x):
        r"""
        find(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::set< unsigned long long >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        """
        return _NvRules.set_ull_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::set< unsigned long long >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        """
        return _NvRules.set_ull_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::set< unsigned long long >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        """
        return _NvRules.set_ull_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(set_ull self, std::set< unsigned long long >::key_type const & x) -> std::pair< std::set< unsigned long long >::iterator,std::set< unsigned long long >::iterator >

        Parameters
        ----------
        x: std::set< unsigned long long >::key_type const &

        """
        return _NvRules.set_ull_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(set_ull self, std::set< unsigned long long >::value_type const & __x) -> std::pair< std::set< unsigned long long >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned long long >::value_type const &

        """
        return _NvRules.set_ull_insert(self, __x)
    __swig_destroy__ = _NvRules.delete_set_ull

# Register set_ull in _NvRules:
_NvRules.set_ull_swigregister(set_ull)
class vector_string(object):
    r"""Proxy of C++ std::vector< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(vector_string self) -> SwigPyIterator"""
        return _NvRules.vector_string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_string self) -> bool"""
        return _NvRules.vector_string___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_string self) -> bool"""
        return _NvRules.vector_string___bool__(self)

    def __len__(self):
        r"""__len__(vector_string self) -> std::vector< std::string >::size_type"""
        return _NvRules.vector_string___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _NvRules.vector_string___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _NvRules.vector_string___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _NvRules.vector_string___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_string self, std::vector< std::string >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(vector_string self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _NvRules.vector_string___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_string self, SWIGPY_SLICEOBJECT * slice) -> vector_string

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(vector_string self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _NvRules.vector_string___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_string self, SWIGPY_SLICEOBJECT * slice, vector_string v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(vector_string self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_string self) -> std::vector< std::string >::value_type"""
        return _NvRules.vector_string_pop(self)

    def append(self, x):
        r"""
        append(vector_string self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string_append(self, x)

    def empty(self):
        r"""empty(vector_string self) -> bool"""
        return _NvRules.vector_string_empty(self)

    def size(self):
        r"""size(vector_string self) -> std::vector< std::string >::size_type"""
        return _NvRules.vector_string_size(self)

    def swap(self, v):
        r"""
        swap(vector_string self, vector_string v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _NvRules.vector_string_swap(self, v)

    def begin(self):
        r"""begin(vector_string self) -> std::vector< std::string >::iterator"""
        return _NvRules.vector_string_begin(self)

    def end(self):
        r"""end(vector_string self) -> std::vector< std::string >::iterator"""
        return _NvRules.vector_string_end(self)

    def rbegin(self):
        r"""rbegin(vector_string self) -> std::vector< std::string >::reverse_iterator"""
        return _NvRules.vector_string_rbegin(self)

    def rend(self):
        r"""rend(vector_string self) -> std::vector< std::string >::reverse_iterator"""
        return _NvRules.vector_string_rend(self)

    def clear(self):
        r"""clear(vector_string self)"""
        return _NvRules.vector_string_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_string self) -> std::vector< std::string >::allocator_type"""
        return _NvRules.vector_string_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_string self)"""
        return _NvRules.vector_string_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_string self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(vector_string self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _NvRules.vector_string_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_string self) -> vector_string
        __init__(vector_string self, vector_string other) -> vector_string

        Parameters
        ----------
        other: std::vector< std::string > const &

        __init__(vector_string self, std::vector< std::string >::size_type size) -> vector_string

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(vector_string self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        _NvRules.vector_string_swiginit(self, _NvRules.new_vector_string(*args))

    def push_back(self, x):
        r"""
        push_back(vector_string self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string_push_back(self, x)

    def front(self):
        r"""front(vector_string self) -> std::vector< std::string >::value_type const &"""
        return _NvRules.vector_string_front(self)

    def back(self):
        r"""back(vector_string self) -> std::vector< std::string >::value_type const &"""
        return _NvRules.vector_string_back(self)

    def assign(self, n, x):
        r"""
        assign(vector_string self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_string self, std::vector< std::string >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(vector_string self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _NvRules.vector_string_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(vector_string self, std::vector< std::string >::size_type n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _NvRules.vector_string_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_string self) -> std::vector< std::string >::size_type"""
        return _NvRules.vector_string_capacity(self)
    __swig_destroy__ = _NvRules.delete_vector_string

# Register vector_string in _NvRules:
_NvRules.vector_string_swigregister(vector_string)
class vector_double(object):
    r"""Proxy of C++ std::vector< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(vector_double self) -> SwigPyIterator"""
        return _NvRules.vector_double_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_double self) -> bool"""
        return _NvRules.vector_double___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_double self) -> bool"""
        return _NvRules.vector_double___bool__(self)

    def __len__(self):
        r"""__len__(vector_double self) -> std::vector< double >::size_type"""
        return _NvRules.vector_double___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vector_double

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _NvRules.vector_double___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        __setslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vector_double v)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type
        v: std::vector< double,std::allocator< double > > const &

        """
        return _NvRules.vector_double___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _NvRules.vector_double___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_double self, std::vector< double >::difference_type i)

        Parameters
        ----------
        i: std::vector< double >::difference_type

        __delitem__(vector_double self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _NvRules.vector_double___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_double self, SWIGPY_SLICEOBJECT * slice) -> vector_double

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(vector_double self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &

        Parameters
        ----------
        i: std::vector< double >::difference_type

        """
        return _NvRules.vector_double___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_double self, SWIGPY_SLICEOBJECT * slice, vector_double v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< double,std::allocator< double > > const &

        __setitem__(vector_double self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_double self) -> std::vector< double >::value_type"""
        return _NvRules.vector_double_pop(self)

    def append(self, x):
        r"""
        append(vector_double self, std::vector< double >::value_type const & x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double_append(self, x)

    def empty(self):
        r"""empty(vector_double self) -> bool"""
        return _NvRules.vector_double_empty(self)

    def size(self):
        r"""size(vector_double self) -> std::vector< double >::size_type"""
        return _NvRules.vector_double_size(self)

    def swap(self, v):
        r"""
        swap(vector_double self, vector_double v)

        Parameters
        ----------
        v: std::vector< double > &

        """
        return _NvRules.vector_double_swap(self, v)

    def begin(self):
        r"""begin(vector_double self) -> std::vector< double >::iterator"""
        return _NvRules.vector_double_begin(self)

    def end(self):
        r"""end(vector_double self) -> std::vector< double >::iterator"""
        return _NvRules.vector_double_end(self)

    def rbegin(self):
        r"""rbegin(vector_double self) -> std::vector< double >::reverse_iterator"""
        return _NvRules.vector_double_rbegin(self)

    def rend(self):
        r"""rend(vector_double self) -> std::vector< double >::reverse_iterator"""
        return _NvRules.vector_double_rend(self)

    def clear(self):
        r"""clear(vector_double self)"""
        return _NvRules.vector_double_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_double self) -> std::vector< double >::allocator_type"""
        return _NvRules.vector_double_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_double self)"""
        return _NvRules.vector_double_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_double self, std::vector< double >::iterator pos) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator

        erase(vector_double self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator

        Parameters
        ----------
        first: std::vector< double >::iterator
        last: std::vector< double >::iterator

        """
        return _NvRules.vector_double_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_double self) -> vector_double
        __init__(vector_double self, vector_double other) -> vector_double

        Parameters
        ----------
        other: std::vector< double > const &

        __init__(vector_double self, std::vector< double >::size_type size) -> vector_double

        Parameters
        ----------
        size: std::vector< double >::size_type

        __init__(vector_double self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vector_double

        Parameters
        ----------
        size: std::vector< double >::size_type
        value: std::vector< double >::value_type const &

        """
        _NvRules.vector_double_swiginit(self, _NvRules.new_vector_double(*args))

    def push_back(self, x):
        r"""
        push_back(vector_double self, std::vector< double >::value_type const & x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double_push_back(self, x)

    def front(self):
        r"""front(vector_double self) -> std::vector< double >::value_type const &"""
        return _NvRules.vector_double_front(self)

    def back(self):
        r"""back(vector_double self) -> std::vector< double >::value_type const &"""
        return _NvRules.vector_double_back(self)

    def assign(self, n, x):
        r"""
        assign(vector_double self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

        Parameters
        ----------
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_double self, std::vector< double >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< double >::size_type

        resize(vector_double self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_double self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator
        x: std::vector< double >::value_type const &

        insert(vector_double self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< double >::iterator
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _NvRules.vector_double_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(vector_double self, std::vector< double >::size_type n)

        Parameters
        ----------
        n: std::vector< double >::size_type

        """
        return _NvRules.vector_double_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_double self) -> std::vector< double >::size_type"""
        return _NvRules.vector_double_capacity(self)
    __swig_destroy__ = _NvRules.delete_vector_double

# Register vector_double in _NvRules:
_NvRules.vector_double_swigregister(vector_double)
class vector_longlong(object):
    r"""Proxy of C++ std::vector< long long > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(vector_longlong self) -> SwigPyIterator"""
        return _NvRules.vector_longlong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_longlong self) -> bool"""
        return _NvRules.vector_longlong___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_longlong self) -> bool"""
        return _NvRules.vector_longlong___bool__(self)

    def __len__(self):
        r"""__len__(vector_longlong self) -> std::vector< long long >::size_type"""
        return _NvRules.vector_longlong___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(vector_longlong self, std::vector< long long >::difference_type i, std::vector< long long >::difference_type j) -> vector_longlong

        Parameters
        ----------
        i: std::vector< long long >::difference_type
        j: std::vector< long long >::difference_type

        """
        return _NvRules.vector_longlong___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_longlong self, std::vector< long long >::difference_type i, std::vector< long long >::difference_type j)

        Parameters
        ----------
        i: std::vector< long long >::difference_type
        j: std::vector< long long >::difference_type

        __setslice__(vector_longlong self, std::vector< long long >::difference_type i, std::vector< long long >::difference_type j, vector_longlong v)

        Parameters
        ----------
        i: std::vector< long long >::difference_type
        j: std::vector< long long >::difference_type
        v: std::vector< long long,std::allocator< long long > > const &

        """
        return _NvRules.vector_longlong___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(vector_longlong self, std::vector< long long >::difference_type i, std::vector< long long >::difference_type j)

        Parameters
        ----------
        i: std::vector< long long >::difference_type
        j: std::vector< long long >::difference_type

        """
        return _NvRules.vector_longlong___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_longlong self, std::vector< long long >::difference_type i)

        Parameters
        ----------
        i: std::vector< long long >::difference_type

        __delitem__(vector_longlong self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _NvRules.vector_longlong___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_longlong self, SWIGPY_SLICEOBJECT * slice) -> vector_longlong

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(vector_longlong self, std::vector< long long >::difference_type i) -> std::vector< long long >::value_type const &

        Parameters
        ----------
        i: std::vector< long long >::difference_type

        """
        return _NvRules.vector_longlong___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_longlong self, SWIGPY_SLICEOBJECT * slice, vector_longlong v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< long long,std::allocator< long long > > const &

        __setitem__(vector_longlong self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(vector_longlong self, std::vector< long long >::difference_type i, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        i: std::vector< long long >::difference_type
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_longlong self) -> std::vector< long long >::value_type"""
        return _NvRules.vector_longlong_pop(self)

    def append(self, x):
        r"""
        append(vector_longlong self, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong_append(self, x)

    def empty(self):
        r"""empty(vector_longlong self) -> bool"""
        return _NvRules.vector_longlong_empty(self)

    def size(self):
        r"""size(vector_longlong self) -> std::vector< long long >::size_type"""
        return _NvRules.vector_longlong_size(self)

    def swap(self, v):
        r"""
        swap(vector_longlong self, vector_longlong v)

        Parameters
        ----------
        v: std::vector< long long > &

        """
        return _NvRules.vector_longlong_swap(self, v)

    def begin(self):
        r"""begin(vector_longlong self) -> std::vector< long long >::iterator"""
        return _NvRules.vector_longlong_begin(self)

    def end(self):
        r"""end(vector_longlong self) -> std::vector< long long >::iterator"""
        return _NvRules.vector_longlong_end(self)

    def rbegin(self):
        r"""rbegin(vector_longlong self) -> std::vector< long long >::reverse_iterator"""
        return _NvRules.vector_longlong_rbegin(self)

    def rend(self):
        r"""rend(vector_longlong self) -> std::vector< long long >::reverse_iterator"""
        return _NvRules.vector_longlong_rend(self)

    def clear(self):
        r"""clear(vector_longlong self)"""
        return _NvRules.vector_longlong_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_longlong self) -> std::vector< long long >::allocator_type"""
        return _NvRules.vector_longlong_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_longlong self)"""
        return _NvRules.vector_longlong_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_longlong self, std::vector< long long >::iterator pos) -> std::vector< long long >::iterator

        Parameters
        ----------
        pos: std::vector< long long >::iterator

        erase(vector_longlong self, std::vector< long long >::iterator first, std::vector< long long >::iterator last) -> std::vector< long long >::iterator

        Parameters
        ----------
        first: std::vector< long long >::iterator
        last: std::vector< long long >::iterator

        """
        return _NvRules.vector_longlong_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_longlong self) -> vector_longlong
        __init__(vector_longlong self, vector_longlong other) -> vector_longlong

        Parameters
        ----------
        other: std::vector< long long > const &

        __init__(vector_longlong self, std::vector< long long >::size_type size) -> vector_longlong

        Parameters
        ----------
        size: std::vector< long long >::size_type

        __init__(vector_longlong self, std::vector< long long >::size_type size, std::vector< long long >::value_type const & value) -> vector_longlong

        Parameters
        ----------
        size: std::vector< long long >::size_type
        value: std::vector< long long >::value_type const &

        """
        _NvRules.vector_longlong_swiginit(self, _NvRules.new_vector_longlong(*args))

    def push_back(self, x):
        r"""
        push_back(vector_longlong self, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong_push_back(self, x)

    def front(self):
        r"""front(vector_longlong self) -> std::vector< long long >::value_type const &"""
        return _NvRules.vector_longlong_front(self)

    def back(self):
        r"""back(vector_longlong self) -> std::vector< long long >::value_type const &"""
        return _NvRules.vector_longlong_back(self)

    def assign(self, n, x):
        r"""
        assign(vector_longlong self, std::vector< long long >::size_type n, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        n: std::vector< long long >::size_type
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_longlong self, std::vector< long long >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< long long >::size_type

        resize(vector_longlong self, std::vector< long long >::size_type new_size, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< long long >::size_type
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_longlong self, std::vector< long long >::iterator pos, std::vector< long long >::value_type const & x) -> std::vector< long long >::iterator

        Parameters
        ----------
        pos: std::vector< long long >::iterator
        x: std::vector< long long >::value_type const &

        insert(vector_longlong self, std::vector< long long >::iterator pos, std::vector< long long >::size_type n, std::vector< long long >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< long long >::iterator
        n: std::vector< long long >::size_type
        x: std::vector< long long >::value_type const &

        """
        return _NvRules.vector_longlong_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(vector_longlong self, std::vector< long long >::size_type n)

        Parameters
        ----------
        n: std::vector< long long >::size_type

        """
        return _NvRules.vector_longlong_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_longlong self) -> std::vector< long long >::size_type"""
        return _NvRules.vector_longlong_capacity(self)
    __swig_destroy__ = _NvRules.delete_vector_longlong

# Register vector_longlong in _NvRules:
_NvRules.vector_longlong_swigregister(vector_longlong)
class vector_ull(object):
    r"""Proxy of C++ std::vector< unsigned long long > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(vector_ull self) -> SwigPyIterator"""
        return _NvRules.vector_ull_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_ull self) -> bool"""
        return _NvRules.vector_ull___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_ull self) -> bool"""
        return _NvRules.vector_ull___bool__(self)

    def __len__(self):
        r"""__len__(vector_ull self) -> std::vector< unsigned long long >::size_type"""
        return _NvRules.vector_ull___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(vector_ull self, std::vector< unsigned long long >::difference_type i, std::vector< unsigned long long >::difference_type j) -> vector_ull

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type
        j: std::vector< unsigned long long >::difference_type

        """
        return _NvRules.vector_ull___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_ull self, std::vector< unsigned long long >::difference_type i, std::vector< unsigned long long >::difference_type j)

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type
        j: std::vector< unsigned long long >::difference_type

        __setslice__(vector_ull self, std::vector< unsigned long long >::difference_type i, std::vector< unsigned long long >::difference_type j, vector_ull v)

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type
        j: std::vector< unsigned long long >::difference_type
        v: std::vector< unsigned long long,std::allocator< unsigned long long > > const &

        """
        return _NvRules.vector_ull___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(vector_ull self, std::vector< unsigned long long >::difference_type i, std::vector< unsigned long long >::difference_type j)

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type
        j: std::vector< unsigned long long >::difference_type

        """
        return _NvRules.vector_ull___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_ull self, std::vector< unsigned long long >::difference_type i)

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type

        __delitem__(vector_ull self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _NvRules.vector_ull___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_ull self, SWIGPY_SLICEOBJECT * slice) -> vector_ull

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(vector_ull self, std::vector< unsigned long long >::difference_type i) -> std::vector< unsigned long long >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type

        """
        return _NvRules.vector_ull___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_ull self, SWIGPY_SLICEOBJECT * slice, vector_ull v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< unsigned long long,std::allocator< unsigned long long > > const &

        __setitem__(vector_ull self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(vector_ull self, std::vector< unsigned long long >::difference_type i, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        i: std::vector< unsigned long long >::difference_type
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_ull self) -> std::vector< unsigned long long >::value_type"""
        return _NvRules.vector_ull_pop(self)

    def append(self, x):
        r"""
        append(vector_ull self, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull_append(self, x)

    def empty(self):
        r"""empty(vector_ull self) -> bool"""
        return _NvRules.vector_ull_empty(self)

    def size(self):
        r"""size(vector_ull self) -> std::vector< unsigned long long >::size_type"""
        return _NvRules.vector_ull_size(self)

    def swap(self, v):
        r"""
        swap(vector_ull self, vector_ull v)

        Parameters
        ----------
        v: std::vector< unsigned long long > &

        """
        return _NvRules.vector_ull_swap(self, v)

    def begin(self):
        r"""begin(vector_ull self) -> std::vector< unsigned long long >::iterator"""
        return _NvRules.vector_ull_begin(self)

    def end(self):
        r"""end(vector_ull self) -> std::vector< unsigned long long >::iterator"""
        return _NvRules.vector_ull_end(self)

    def rbegin(self):
        r"""rbegin(vector_ull self) -> std::vector< unsigned long long >::reverse_iterator"""
        return _NvRules.vector_ull_rbegin(self)

    def rend(self):
        r"""rend(vector_ull self) -> std::vector< unsigned long long >::reverse_iterator"""
        return _NvRules.vector_ull_rend(self)

    def clear(self):
        r"""clear(vector_ull self)"""
        return _NvRules.vector_ull_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_ull self) -> std::vector< unsigned long long >::allocator_type"""
        return _NvRules.vector_ull_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_ull self)"""
        return _NvRules.vector_ull_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_ull self, std::vector< unsigned long long >::iterator pos) -> std::vector< unsigned long long >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned long long >::iterator

        erase(vector_ull self, std::vector< unsigned long long >::iterator first, std::vector< unsigned long long >::iterator last) -> std::vector< unsigned long long >::iterator

        Parameters
        ----------
        first: std::vector< unsigned long long >::iterator
        last: std::vector< unsigned long long >::iterator

        """
        return _NvRules.vector_ull_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_ull self) -> vector_ull
        __init__(vector_ull self, vector_ull other) -> vector_ull

        Parameters
        ----------
        other: std::vector< unsigned long long > const &

        __init__(vector_ull self, std::vector< unsigned long long >::size_type size) -> vector_ull

        Parameters
        ----------
        size: std::vector< unsigned long long >::size_type

        __init__(vector_ull self, std::vector< unsigned long long >::size_type size, std::vector< unsigned long long >::value_type const & value) -> vector_ull

        Parameters
        ----------
        size: std::vector< unsigned long long >::size_type
        value: std::vector< unsigned long long >::value_type const &

        """
        _NvRules.vector_ull_swiginit(self, _NvRules.new_vector_ull(*args))

    def push_back(self, x):
        r"""
        push_back(vector_ull self, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull_push_back(self, x)

    def front(self):
        r"""front(vector_ull self) -> std::vector< unsigned long long >::value_type const &"""
        return _NvRules.vector_ull_front(self)

    def back(self):
        r"""back(vector_ull self) -> std::vector< unsigned long long >::value_type const &"""
        return _NvRules.vector_ull_back(self)

    def assign(self, n, x):
        r"""
        assign(vector_ull self, std::vector< unsigned long long >::size_type n, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        n: std::vector< unsigned long long >::size_type
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_ull self, std::vector< unsigned long long >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned long long >::size_type

        resize(vector_ull self, std::vector< unsigned long long >::size_type new_size, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< unsigned long long >::size_type
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_ull self, std::vector< unsigned long long >::iterator pos, std::vector< unsigned long long >::value_type const & x) -> std::vector< unsigned long long >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned long long >::iterator
        x: std::vector< unsigned long long >::value_type const &

        insert(vector_ull self, std::vector< unsigned long long >::iterator pos, std::vector< unsigned long long >::size_type n, std::vector< unsigned long long >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< unsigned long long >::iterator
        n: std::vector< unsigned long long >::size_type
        x: std::vector< unsigned long long >::value_type const &

        """
        return _NvRules.vector_ull_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(vector_ull self, std::vector< unsigned long long >::size_type n)

        Parameters
        ----------
        n: std::vector< unsigned long long >::size_type

        """
        return _NvRules.vector_ull_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_ull self) -> std::vector< unsigned long long >::size_type"""
        return _NvRules.vector_ull_capacity(self)
    __swig_destroy__ = _NvRules.delete_vector_ull

# Register vector_ull in _NvRules:
_NvRules.vector_ull_swigregister(vector_ull)
class vector_table_column(object):
    r"""Proxy of C++ std::vector< NV::Rules::TableColumn > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(vector_table_column self) -> SwigPyIterator"""
        return _NvRules.vector_table_column_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_table_column self) -> bool"""
        return _NvRules.vector_table_column___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_table_column self) -> bool"""
        return _NvRules.vector_table_column___bool__(self)

    def __len__(self):
        r"""__len__(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::size_type"""
        return _NvRules.vector_table_column___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i, std::vector< NV::Rules::TableColumn >::difference_type j) -> vector_table_column

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type
        j: std::vector< NV::Rules::TableColumn >::difference_type

        """
        return _NvRules.vector_table_column___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i, std::vector< NV::Rules::TableColumn >::difference_type j)

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type
        j: std::vector< NV::Rules::TableColumn >::difference_type

        __setslice__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i, std::vector< NV::Rules::TableColumn >::difference_type j, vector_table_column v)

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type
        j: std::vector< NV::Rules::TableColumn >::difference_type
        v: std::vector< NV::Rules::TableColumn,std::allocator< NV::Rules::TableColumn > > const &

        """
        return _NvRules.vector_table_column___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i, std::vector< NV::Rules::TableColumn >::difference_type j)

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type
        j: std::vector< NV::Rules::TableColumn >::difference_type

        """
        return _NvRules.vector_table_column___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i)

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type

        __delitem__(vector_table_column self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _NvRules.vector_table_column___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_table_column self, SWIGPY_SLICEOBJECT * slice) -> vector_table_column

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i) -> TableColumn

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type

        """
        return _NvRules.vector_table_column___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_table_column self, SWIGPY_SLICEOBJECT * slice, vector_table_column v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< NV::Rules::TableColumn,std::allocator< NV::Rules::TableColumn > > const &

        __setitem__(vector_table_column self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(vector_table_column self, std::vector< NV::Rules::TableColumn >::difference_type i, TableColumn x)

        Parameters
        ----------
        i: std::vector< NV::Rules::TableColumn >::difference_type
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_table_column self) -> TableColumn"""
        return _NvRules.vector_table_column_pop(self)

    def append(self, x):
        r"""
        append(vector_table_column self, TableColumn x)

        Parameters
        ----------
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column_append(self, x)

    def empty(self):
        r"""empty(vector_table_column self) -> bool"""
        return _NvRules.vector_table_column_empty(self)

    def size(self):
        r"""size(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::size_type"""
        return _NvRules.vector_table_column_size(self)

    def swap(self, v):
        r"""
        swap(vector_table_column self, vector_table_column v)

        Parameters
        ----------
        v: std::vector< NV::Rules::TableColumn > &

        """
        return _NvRules.vector_table_column_swap(self, v)

    def begin(self):
        r"""begin(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::iterator"""
        return _NvRules.vector_table_column_begin(self)

    def end(self):
        r"""end(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::iterator"""
        return _NvRules.vector_table_column_end(self)

    def rbegin(self):
        r"""rbegin(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::reverse_iterator"""
        return _NvRules.vector_table_column_rbegin(self)

    def rend(self):
        r"""rend(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::reverse_iterator"""
        return _NvRules.vector_table_column_rend(self)

    def clear(self):
        r"""clear(vector_table_column self)"""
        return _NvRules.vector_table_column_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::allocator_type"""
        return _NvRules.vector_table_column_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_table_column self)"""
        return _NvRules.vector_table_column_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_table_column self, std::vector< NV::Rules::TableColumn >::iterator pos) -> std::vector< NV::Rules::TableColumn >::iterator

        Parameters
        ----------
        pos: std::vector< NV::Rules::TableColumn >::iterator

        erase(vector_table_column self, std::vector< NV::Rules::TableColumn >::iterator first, std::vector< NV::Rules::TableColumn >::iterator last) -> std::vector< NV::Rules::TableColumn >::iterator

        Parameters
        ----------
        first: std::vector< NV::Rules::TableColumn >::iterator
        last: std::vector< NV::Rules::TableColumn >::iterator

        """
        return _NvRules.vector_table_column_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_table_column self) -> vector_table_column
        __init__(vector_table_column self, vector_table_column other) -> vector_table_column

        Parameters
        ----------
        other: std::vector< NV::Rules::TableColumn > const &

        __init__(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type size) -> vector_table_column

        Parameters
        ----------
        size: std::vector< NV::Rules::TableColumn >::size_type

        __init__(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type size, TableColumn value) -> vector_table_column

        Parameters
        ----------
        size: std::vector< NV::Rules::TableColumn >::size_type
        value: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        _NvRules.vector_table_column_swiginit(self, _NvRules.new_vector_table_column(*args))

    def push_back(self, x):
        r"""
        push_back(vector_table_column self, TableColumn x)

        Parameters
        ----------
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column_push_back(self, x)

    def front(self):
        r"""front(vector_table_column self) -> TableColumn"""
        return _NvRules.vector_table_column_front(self)

    def back(self):
        r"""back(vector_table_column self) -> TableColumn"""
        return _NvRules.vector_table_column_back(self)

    def assign(self, n, x):
        r"""
        assign(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type n, TableColumn x)

        Parameters
        ----------
        n: std::vector< NV::Rules::TableColumn >::size_type
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< NV::Rules::TableColumn >::size_type

        resize(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type new_size, TableColumn x)

        Parameters
        ----------
        new_size: std::vector< NV::Rules::TableColumn >::size_type
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_table_column self, std::vector< NV::Rules::TableColumn >::iterator pos, TableColumn x) -> std::vector< NV::Rules::TableColumn >::iterator

        Parameters
        ----------
        pos: std::vector< NV::Rules::TableColumn >::iterator
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        insert(vector_table_column self, std::vector< NV::Rules::TableColumn >::iterator pos, std::vector< NV::Rules::TableColumn >::size_type n, TableColumn x)

        Parameters
        ----------
        pos: std::vector< NV::Rules::TableColumn >::iterator
        n: std::vector< NV::Rules::TableColumn >::size_type
        x: std::vector< NV::Rules::TableColumn >::value_type const &

        """
        return _NvRules.vector_table_column_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(vector_table_column self, std::vector< NV::Rules::TableColumn >::size_type n)

        Parameters
        ----------
        n: std::vector< NV::Rules::TableColumn >::size_type

        """
        return _NvRules.vector_table_column_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_table_column self) -> std::vector< NV::Rules::TableColumn >::size_type"""
        return _NvRules.vector_table_column_capacity(self)
    __swig_destroy__ = _NvRules.delete_vector_table_column

# Register vector_table_column in _NvRules:
_NvRules.vector_table_column_swigregister(vector_table_column)

def require_metrics(handle, metrics):
    ev = get_evaluator(handle)
    for metric in metrics:
        ev.require_metric(metric)

def require_rules(handle, rules):
    ev = get_evaluator(handle)
    for rule in rules:
        ev.require_rule(rule)

def metric_instances(metric):
    instances = []

    for idx in range(metric.num_instances()):
        kind = metric.kind(idx)
        if (kind == IMetric.ValueKind_FLOAT) or (kind == IMetric.ValueKind_DOUBLE):
            instances.append(metric.as_double(idx))
        elif (kind == IMetric.ValueKind_UINT64) or (kind == IMetric.ValueKind_UINT32):
            instances.append(metric.as_uint64(idx))
        else:
            instances.append(metric.as_string(idx))

    return instances

RuleKind_DEFAULT = _NvRules.RuleKind_DEFAULT

RuleKind_GUIDED = _NvRules.RuleKind_GUIDED

class IMetric(object):
    r"""Proxy of C++ NV::Rules::IMetric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    ValueKind_UNKNOWN = _NvRules.IMetric_ValueKind_UNKNOWN
    
    ValueKind_ANY = _NvRules.IMetric_ValueKind_ANY
    
    ValueKind_STRING = _NvRules.IMetric_ValueKind_STRING
    
    ValueKind_FLOAT = _NvRules.IMetric_ValueKind_FLOAT
    
    ValueKind_DOUBLE = _NvRules.IMetric_ValueKind_DOUBLE
    
    ValueKind_UINT32 = _NvRules.IMetric_ValueKind_UINT32
    
    ValueKind_UINT64 = _NvRules.IMetric_ValueKind_UINT64
    
    MetricType_OTHER = _NvRules.IMetric_MetricType_OTHER
    
    MetricType_COUNTER = _NvRules.IMetric_MetricType_COUNTER
    
    MetricType_RATIO = _NvRules.IMetric_MetricType_RATIO
    
    MetricType_THROUGHPUT = _NvRules.IMetric_MetricType_THROUGHPUT
    
    MetricSubtype_NONE = _NvRules.IMetric_MetricSubtype_NONE
    
    MetricSubtype_PEAK_SUSTAINED = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED
    
    MetricSubtype_PEAK_SUSTAINED_ACTIVE = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_ACTIVE
    
    MetricSubtype_PEAK_SUSTAINED_ACTIVE_PER_SECOND = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_ACTIVE_PER_SECOND
    
    MetricSubtype_PEAK_SUSTAINED_ELAPSED = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_ELAPSED
    
    MetricSubtype_PEAK_SUSTAINED_ELAPSED_PER_SECOND = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_ELAPSED_PER_SECOND
    
    MetricSubtype_PEAK_SUSTAINED_FRAME = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_FRAME
    
    MetricSubtype_PEAK_SUSTAINED_FRAME_PER_SECOND = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_FRAME_PER_SECOND
    
    MetricSubtype_PEAK_SUSTAINED_REGION = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_REGION
    
    MetricSubtype_PEAK_SUSTAINED_REGION_PER_SECOND = _NvRules.IMetric_MetricSubtype_PEAK_SUSTAINED_REGION_PER_SECOND
    
    MetricSubtype_PER_CYCLE_ACTIVE = _NvRules.IMetric_MetricSubtype_PER_CYCLE_ACTIVE
    
    MetricSubtype_PER_CYCLE_ELAPSED = _NvRules.IMetric_MetricSubtype_PER_CYCLE_ELAPSED
    
    MetricSubtype_PER_CYCLE_IN_FRAME = _NvRules.IMetric_MetricSubtype_PER_CYCLE_IN_FRAME
    
    MetricSubtype_PER_CYCLE_IN_REGION = _NvRules.IMetric_MetricSubtype_PER_CYCLE_IN_REGION
    
    MetricSubtype_PER_SECOND = _NvRules.IMetric_MetricSubtype_PER_SECOND
    
    MetricSubtype_PCT_OF_PEAK_SUSTAINED_ACTIVE = _NvRules.IMetric_MetricSubtype_PCT_OF_PEAK_SUSTAINED_ACTIVE
    
    MetricSubtype_PCT_OF_PEAK_SUSTAINED_ELAPSED = _NvRules.IMetric_MetricSubtype_PCT_OF_PEAK_SUSTAINED_ELAPSED
    
    MetricSubtype_PCT_OF_PEAK_SUSTAINED_FRAME = _NvRules.IMetric_MetricSubtype_PCT_OF_PEAK_SUSTAINED_FRAME
    
    MetricSubtype_PCT_OF_PEAK_SUSTAINED_REGION = _NvRules.IMetric_MetricSubtype_PCT_OF_PEAK_SUSTAINED_REGION
    
    MetricSubtype_MAX_RATE = _NvRules.IMetric_MetricSubtype_MAX_RATE
    
    MetricSubtype_PCT = _NvRules.IMetric_MetricSubtype_PCT
    
    MetricSubtype_RATIO = _NvRules.IMetric_MetricSubtype_RATIO
    
    RollupOperation_NONE = _NvRules.IMetric_RollupOperation_NONE
    
    RollupOperation_AVG = _NvRules.IMetric_RollupOperation_AVG
    
    RollupOperation_MAX = _NvRules.IMetric_RollupOperation_MAX
    
    RollupOperation_MIN = _NvRules.IMetric_RollupOperation_MIN
    
    RollupOperation_SUM = _NvRules.IMetric_RollupOperation_SUM
    
    __swig_destroy__ = _NvRules.delete_IMetric

    def name(self):
        r"""name(IMetric self) -> char const *"""
        return _NvRules.IMetric_name(self)

    def metric_type(self):
        r"""metric_type(IMetric self) -> NV::Rules::IMetric::MetricType"""
        return _NvRules.IMetric_metric_type(self)

    def metric_subtype(self):
        r"""metric_subtype(IMetric self) -> NV::Rules::IMetric::MetricSubtype"""
        return _NvRules.IMetric_metric_subtype(self)

    def rollup_operation(self):
        r"""rollup_operation(IMetric self) -> NV::Rules::IMetric::RollupOperation"""
        return _NvRules.IMetric_rollup_operation(self)

    def unit(self):
        r"""unit(IMetric self) -> NV::Rules::IMetric::Unit"""
        return _NvRules.IMetric_unit(self)

    def description(self):
        r"""description(IMetric self) -> NV::Rules::IMetric::Description"""
        return _NvRules.IMetric_description(self)

    def kind(self, *args):
        r"""
        kind(IMetric self) -> NV::Rules::IMetric::ValueKind
        kind(IMetric self, size_t instance) -> NV::Rules::IMetric::ValueKind

        Parameters
        ----------
        instance: size_t

        """
        return _NvRules.IMetric_kind(self, *args)

    def has_value(self, *args):
        r"""
        has_value(IMetric self) -> bool
        has_value(IMetric self, NV::Rules::IMetric::ValueKind value_kind) -> bool

        Parameters
        ----------
        value_kind: enum NV::Rules::IMetric::ValueKind

        """
        return _NvRules.IMetric_has_value(self, *args)

    def as_double(self, *args):
        r"""
        as_double(IMetric self) -> double
        as_double(IMetric self, size_t instance) -> double

        Parameters
        ----------
        instance: size_t

        """
        return _NvRules.IMetric_as_double(self, *args)

    def as_uint64(self, *args):
        r"""
        as_uint64(IMetric self) -> uint64_t
        as_uint64(IMetric self, size_t instance) -> uint64_t

        Parameters
        ----------
        instance: size_t

        """
        return _NvRules.IMetric_as_uint64(self, *args)

    def as_string(self, *args):
        r"""
        as_string(IMetric self) -> char const
        as_string(IMetric self, size_t instance) -> char const *

        Parameters
        ----------
        instance: size_t

        """
        return _NvRules.IMetric_as_string(self, *args)

    def num_instances(self):
        r"""num_instances(IMetric self) -> size_t"""
        return _NvRules.IMetric_num_instances(self)

    def has_correlation_ids(self):
        r"""has_correlation_ids(IMetric self) -> bool"""
        return _NvRules.IMetric_has_correlation_ids(self)

    def correlation_ids(self):
        r"""correlation_ids(IMetric self) -> IMetric"""
        return _NvRules.IMetric_correlation_ids(self)

# Register IMetric in _NvRules:
_NvRules.IMetric_swigregister(IMetric)
class ISourceInfo(object):
    r"""Proxy of C++ NV::Rules::ISourceInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_ISourceInfo

    def file_name(self):
        r"""file_name(ISourceInfo self) -> char const *"""
        return _NvRules.ISourceInfo_file_name(self)

    def line(self):
        r"""line(ISourceInfo self) -> uint32_t"""
        return _NvRules.ISourceInfo_line(self)

# Register ISourceInfo in _NvRules:
_NvRules.ISourceInfo_swigregister(ISourceInfo)
class INvtxRange(object):
    r"""Proxy of C++ NV::Rules::INvtxRange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    PayloadType_PAYLOAD_UNKNOWN = _NvRules.INvtxRange_PayloadType_PAYLOAD_UNKNOWN
    
    PayloadType_PAYLOAD_UINT64 = _NvRules.INvtxRange_PayloadType_PAYLOAD_UINT64
    
    PayloadType_PAYLOAD_INT64 = _NvRules.INvtxRange_PayloadType_PAYLOAD_INT64
    
    PayloadType_PAYLOAD_DOUBLE = _NvRules.INvtxRange_PayloadType_PAYLOAD_DOUBLE
    
    PayloadType_PAYLOAD_UINT32 = _NvRules.INvtxRange_PayloadType_PAYLOAD_UINT32
    
    PayloadType_PAYLOAD_INT32 = _NvRules.INvtxRange_PayloadType_PAYLOAD_INT32
    
    PayloadType_PAYLOAD_FLOAT = _NvRules.INvtxRange_PayloadType_PAYLOAD_FLOAT
    
    PayloadType_PAYLOAD_JSON = _NvRules.INvtxRange_PayloadType_PAYLOAD_JSON
    
    __swig_destroy__ = _NvRules.delete_INvtxRange

    def name(self):
        r"""name(INvtxRange self) -> std::string"""
        return _NvRules.INvtxRange_name(self)

    def has_attributes(self):
        r"""has_attributes(INvtxRange self) -> bool"""
        return _NvRules.INvtxRange_has_attributes(self)

    def category(self):
        r"""category(INvtxRange self) -> uint32_t"""
        return _NvRules.INvtxRange_category(self)

    def color(self):
        r"""color(INvtxRange self) -> uint32_t"""
        return _NvRules.INvtxRange_color(self)

    def payload_type(self):
        r"""payload_type(INvtxRange self) -> NV::Rules::INvtxRange::PayloadType"""
        return _NvRules.INvtxRange_payload_type(self)

    def payload_as_uint64(self):
        r"""payload_as_uint64(INvtxRange self) -> uint64_t"""
        return _NvRules.INvtxRange_payload_as_uint64(self)

    def payload_as_double(self):
        r"""payload_as_double(INvtxRange self) -> double"""
        return _NvRules.INvtxRange_payload_as_double(self)

    def payload_as_string(self):
        r"""payload_as_string(INvtxRange self) -> std::string"""
        return _NvRules.INvtxRange_payload_as_string(self)

    def message(self):
        r"""message(INvtxRange self) -> std::string"""
        return _NvRules.INvtxRange_message(self)

# Register INvtxRange in _NvRules:
_NvRules.INvtxRange_swigregister(INvtxRange)
class INvtxDomainInfo(object):
    r"""Proxy of C++ NV::Rules::INvtxDomainInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_INvtxDomainInfo

    def name(self):
        r"""name(INvtxDomainInfo self) -> std::string"""
        return _NvRules.INvtxDomainInfo_name(self)

    def push_pop_ranges(self):
        r"""push_pop_ranges(INvtxDomainInfo self) -> vector_string"""
        return _NvRules.INvtxDomainInfo_push_pop_ranges(self)

    def push_pop_range(self, idx):
        r"""
        push_pop_range(INvtxDomainInfo self, size_t idx) -> INvtxRange

        Parameters
        ----------
        idx: size_t

        """
        return _NvRules.INvtxDomainInfo_push_pop_range(self, idx)

    def start_end_ranges(self):
        r"""start_end_ranges(INvtxDomainInfo self) -> vector_string"""
        return _NvRules.INvtxDomainInfo_start_end_ranges(self)

    def start_end_range(self, idx):
        r"""
        start_end_range(INvtxDomainInfo self, size_t idx) -> INvtxRange

        Parameters
        ----------
        idx: size_t

        """
        return _NvRules.INvtxDomainInfo_start_end_range(self, idx)

# Register INvtxDomainInfo in _NvRules:
_NvRules.INvtxDomainInfo_swigregister(INvtxDomainInfo)
class INvtxState(object):
    r"""Proxy of C++ NV::Rules::INvtxState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_INvtxState

    def domains(self):
        r"""domains(INvtxState self) -> vector_ull"""
        return _NvRules.INvtxState_domains(self)

    def domain_by_id(self, id):
        r"""
        domain_by_id(INvtxState self, unsigned long long id) -> INvtxDomainInfo

        Parameters
        ----------
        id: unsigned long long

        """
        return _NvRules.INvtxState_domain_by_id(self, id)

# Register INvtxState in _NvRules:
_NvRules.INvtxState_swigregister(INvtxState)
class IAction(object):
    r"""Proxy of C++ NV::Rules::IAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    NameBase_FUNCTION = _NvRules.IAction_NameBase_FUNCTION
    
    NameBase_DEMANGLED = _NvRules.IAction_NameBase_DEMANGLED
    
    NameBase_MANGLED = _NvRules.IAction_NameBase_MANGLED
    
    WorkloadType_KERNEL = _NvRules.IAction_WorkloadType_KERNEL
    
    WorkloadType_RANGE = _NvRules.IAction_WorkloadType_RANGE
    
    WorkloadType_CMDLIST = _NvRules.IAction_WorkloadType_CMDLIST
    
    WorkloadType_GRAPH = _NvRules.IAction_WorkloadType_GRAPH
    
    __swig_destroy__ = _NvRules.delete_IAction

    def name(self, *args):
        r"""
        name(IAction self, NV::Rules::IAction::NameBase base=FUNCTION) -> char const

        Parameters
        ----------
        base: enum NV::Rules::IAction::NameBase

        """
        return _NvRules.IAction_name(self, *args)

    def workload_type(self):
        r"""workload_type(IAction self) -> NV::Rules::IAction::WorkloadType"""
        return _NvRules.IAction_workload_type(self)

    def metric_by_name(self, metric_name):
        r"""
        metric_by_name(IAction self, char const * metric_name) -> IMetric

        Parameters
        ----------
        metric_name: char const *

        """
        return _NvRules.IAction_metric_by_name(self, metric_name)

    def metric_names(self):
        r"""metric_names(IAction self) -> set_string"""
        return _NvRules.IAction_metric_names(self)

    def add_integer_metric(self, value_name, value_kind, value):
        r"""
        add_integer_metric(IAction self, char const * value_name, NV::Rules::IMetric::ValueKind value_kind, uint64_t value) -> IMetric

        Parameters
        ----------
        value_name: char const *
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: uint64_t

        """
        return _NvRules.IAction_add_integer_metric(self, value_name, value_kind, value)

    def add_double_metric(self, value_name, value_kind, value):
        r"""
        add_double_metric(IAction self, char const * value_name, NV::Rules::IMetric::ValueKind value_kind, double value) -> IMetric

        Parameters
        ----------
        value_name: char const *
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: double

        """
        return _NvRules.IAction_add_double_metric(self, value_name, value_kind, value)

    def add_string_metric(self, value_name, value_kind, value):
        r"""
        add_string_metric(IAction self, char const * value_name, NV::Rules::IMetric::ValueKind value_kind, char const * value) -> IMetric

        Parameters
        ----------
        value_name: char const *
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: char const *

        """
        return _NvRules.IAction_add_string_metric(self, value_name, value_kind, value)

    def add_metric(self, value_name):
        r"""
        add_metric(IAction self, char const * value_name) -> IMutableMetric

        Parameters
        ----------
        value_name: char const *

        """
        return _NvRules.IAction_add_metric(self, value_name)

    def source_info(self, address):
        r"""
        source_info(IAction self, uint64_t address) -> ISourceInfo

        Parameters
        ----------
        address: uint64_t

        """
        return _NvRules.IAction_source_info(self, address)

    def source_files(self):
        r"""source_files(IAction self) -> map_string_string"""
        return _NvRules.IAction_source_files(self)

    def sass_by_pc(self, address):
        r"""
        sass_by_pc(IAction self, uint64_t address) -> std::string

        Parameters
        ----------
        address: uint64_t

        """
        return _NvRules.IAction_sass_by_pc(self, address)

    def nvtx_state(self):
        r"""nvtx_state(IAction self) -> INvtxState"""
        return _NvRules.IAction_nvtx_state(self)

    def ptx_by_pc(self, address):
        r"""
        ptx_by_pc(IAction self, uint64_t address) -> std::string

        Parameters
        ----------
        address: uint64_t

        """
        return _NvRules.IAction_ptx_by_pc(self, address)

# Register IAction in _NvRules:
_NvRules.IAction_swigregister(IAction)
class IRange(object):
    r"""Proxy of C++ NV::Rules::IRange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IRange

    def num_actions(self):
        r"""num_actions(IRange self) -> size_t"""
        return _NvRules.IRange_num_actions(self)

    def action_by_idx(self, idx):
        r"""
        action_by_idx(IRange self, size_t idx) -> IAction

        Parameters
        ----------
        idx: size_t

        """
        return _NvRules.IRange_action_by_idx(self, idx)

    def actions_by_nvtx(self, includes, excludes):
        r"""
        actions_by_nvtx(IRange self, vector_string includes, vector_string excludes) -> set_ull

        Parameters
        ----------
        includes: std::vector< std::string,std::allocator< std::string > > const &
        excludes: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _NvRules.IRange_actions_by_nvtx(self, includes, excludes)

# Register IRange in _NvRules:
_NvRules.IRange_swigregister(IRange)
class IFrontend(object):
    r"""Proxy of C++ NV::Rules::IFrontend class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    MsgType_MSG_NONE = _NvRules.IFrontend_MsgType_MSG_NONE
    
    MsgType_MSG_OK = _NvRules.IFrontend_MsgType_MSG_OK
    
    MsgType_MSG_OPTIMIZATION = _NvRules.IFrontend_MsgType_MSG_OPTIMIZATION
    
    MsgType_MSG_WARNING = _NvRules.IFrontend_MsgType_MSG_WARNING
    
    MsgType_MSG_ERROR = _NvRules.IFrontend_MsgType_MSG_ERROR
    
    MarkerKind_SASS = _NvRules.IFrontend_MarkerKind_SASS
    
    MarkerKind_SOURCE = _NvRules.IFrontend_MarkerKind_SOURCE
    
    Severity_SEVERITY_DEFAULT = _NvRules.IFrontend_Severity_SEVERITY_DEFAULT
    
    Severity_SEVERITY_LOW = _NvRules.IFrontend_Severity_SEVERITY_LOW
    
    Severity_SEVERITY_HIGH = _NvRules.IFrontend_Severity_SEVERITY_HIGH
    
    SpeedupType_LOCAL = _NvRules.IFrontend_SpeedupType_LOCAL
    
    SpeedupType_GLOBAL = _NvRules.IFrontend_SpeedupType_GLOBAL
    
    __swig_destroy__ = _NvRules.delete_IFrontend

    def message(self, *args):
        r"""
        message(IFrontend self, char const * str, char const * name=None) -> int

        Parameters
        ----------
        str: char const *
        name: char const *

        message(IFrontend self, NV::Rules::IFrontend::MsgType type, char const * str, char const * name=None) -> int

        Parameters
        ----------
        type: enum NV::Rules::IFrontend::MsgType
        str: char const *
        name: char const *

        """
        return _NvRules.IFrontend_message(self, *args)

    def _generate_table(self, message_id, table):
        r"""
        _generate_table(IFrontend self, int message_id, TableData table) -> bool

        Parameters
        ----------
        message_id: int
        table: NV::Rules::TableData const &

        """
        return _NvRules.IFrontend__generate_table(self, message_id, table)

    def send_dict_to_children(self, dict):
        r"""
        send_dict_to_children(IFrontend self, map_string_double dict)

        Parameters
        ----------
        dict: NV::Rules::IFrontend::Dict const &

        """
        return _NvRules.IFrontend_send_dict_to_children(self, dict)

    def receive_dict_from_parent(self, parent_id):
        r"""
        receive_dict_from_parent(IFrontend self, NV::Rules::IFrontend::RuleId const & parent_id) -> map_string_double

        Parameters
        ----------
        parent_id: NV::Rules::IFrontend::RuleId const &

        """
        return _NvRules.IFrontend_receive_dict_from_parent(self, parent_id)

    def speedup(self, message_id, type, estimated_speedup):
        r"""
        speedup(IFrontend self, int message_id, NV::Rules::IFrontend::SpeedupType type, double estimated_speedup) -> bool

        Parameters
        ----------
        message_id: int
        type: enum NV::Rules::IFrontend::SpeedupType
        estimated_speedup: double

        """
        return _NvRules.IFrontend_speedup(self, message_id, type, estimated_speedup)

    def focus_metric(self, message_id, metric_name, metric_value, severity, info):
        r"""
        focus_metric(IFrontend self, int message_id, char const * metric_name, double metric_value, NV::Rules::IFrontend::Severity severity, char const * info) -> bool

        Parameters
        ----------
        message_id: int
        metric_name: char const *
        metric_value: double
        severity: enum NV::Rules::IFrontend::Severity
        info: char const *

        """
        return _NvRules.IFrontend_focus_metric(self, message_id, metric_name, metric_value, severity, info)

    def source_marker(self, *args):
        r"""
        source_marker(IFrontend self, char const * str, uint64_t address_or_line, NV::Rules::IFrontend::MarkerKind kind, NV::Rules::IFrontend::MsgType type=MSG_NONE)

        Parameters
        ----------
        str: char const *
        address_or_line: uint64_t
        kind: enum NV::Rules::IFrontend::MarkerKind
        type: enum NV::Rules::IFrontend::MsgType

        source_marker(IFrontend self, char const * str, uint64_t address_or_line, NV::Rules::IFrontend::MarkerKind kind, char const * file_name, NV::Rules::IFrontend::MsgType type=MSG_NONE)

        Parameters
        ----------
        str: char const *
        address_or_line: uint64_t
        kind: enum NV::Rules::IFrontend::MarkerKind
        file_name: char const *
        type: enum NV::Rules::IFrontend::MsgType

        """
        return _NvRules.IFrontend_source_marker(self, *args)

    def load_chart_from_file(self, filename):
        r"""
        load_chart_from_file(IFrontend self, char const * filename)

        Parameters
        ----------
        filename: char const *

        """
        return _NvRules.IFrontend_load_chart_from_file(self, filename)

# Register IFrontend in _NvRules:
_NvRules.IFrontend_swigregister(IFrontend)
class IBaseContext(object):
    r"""Proxy of C++ NV::Rules::IBaseContext class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IBaseContext

    def handle_exception(self, msg):
        r"""
        handle_exception(IBaseContext self, char const * msg) -> bool

        Parameters
        ----------
        msg: char const *

        """
        return _NvRules.IBaseContext_handle_exception(self, msg)

    def get_version(self):
        r"""get_version(IBaseContext self) -> std::string"""
        return _NvRules.IBaseContext_get_version(self)

# Register IBaseContext in _NvRules:
_NvRules.IBaseContext_swigregister(IBaseContext)
class IMessageVault(object):
    r"""Proxy of C++ NV::Rules::IMessageVault class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IMessageVault

    def Put(self, ruleId, message):
        r"""
        Put(IMessageVault self, NV::Rules::IMessageVault::RuleId const & ruleId, map_string_double message)

        Parameters
        ----------
        ruleId: NV::Rules::IMessageVault::RuleId const &
        message: NV::Rules::IMessageVault::Dict const &

        """
        return _NvRules.IMessageVault_Put(self, ruleId, message)

    def Get(self, ruleId):
        r"""
        Get(IMessageVault self, NV::Rules::IMessageVault::RuleId const & ruleId) -> map_string_double

        Parameters
        ----------
        ruleId: NV::Rules::IMessageVault::RuleId const &

        """
        return _NvRules.IMessageVault_Get(self, ruleId)

# Register IMessageVault in _NvRules:
_NvRules.IMessageVault_swigregister(IMessageVault)
class IController(object):
    r"""Proxy of C++ NV::Rules::IController class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IController

    def propose_rule(self, rule):
        r"""
        propose_rule(IController self, char const * rule)

        Parameters
        ----------
        rule: char const *

        """
        return _NvRules.IController_propose_rule(self, rule)

    def get_message_vault(self):
        r"""get_message_vault(IController self) -> std::shared_ptr< NV::Rules::IMessageVault >"""
        return _NvRules.IController_get_message_vault(self)

# Register IController in _NvRules:
_NvRules.IController_swigregister(IController)
class IEvaluator(IBaseContext):
    r"""Proxy of C++ NV::Rules::IEvaluator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IEvaluator

    def require_metric(self, metric):
        r"""
        require_metric(IEvaluator self, char const * metric)

        Parameters
        ----------
        metric: char const *

        """
        return _NvRules.IEvaluator_require_metric(self, metric)

    def require_rule(self, rule):
        r"""
        require_rule(IEvaluator self, char const * rule)

        Parameters
        ----------
        rule: char const *

        """
        return _NvRules.IEvaluator_require_rule(self, rule)

# Register IEvaluator in _NvRules:
_NvRules.IEvaluator_swigregister(IEvaluator)
class IContext(IBaseContext):
    r"""Proxy of C++ NV::Rules::IContext class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IContext

    def controller(self):
        r"""controller(IContext self) -> IController"""
        return _NvRules.IContext_controller(self)

    def frontend(self):
        r"""frontend(IContext self) -> IFrontend"""
        return _NvRules.IContext_frontend(self)

    def num_ranges(self):
        r"""num_ranges(IContext self) -> size_t"""
        return _NvRules.IContext_num_ranges(self)

    def range_by_idx(self, idx):
        r"""
        range_by_idx(IContext self, size_t idx) -> IRange

        Parameters
        ----------
        idx: size_t

        """
        return _NvRules.IContext_range_by_idx(self, idx)

# Register IContext in _NvRules:
_NvRules.IContext_swigregister(IContext)
class IMutableMetric(IMetric):
    r"""Proxy of C++ NV::Rules::IMutableMetric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _NvRules.delete_IMutableMetric

    def set_double(self, *args):
        r"""
        set_double(IMutableMetric self, NV::Rules::IMetric::ValueKind value_kind, double value) -> bool

        Parameters
        ----------
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: double

        set_double(IMutableMetric self, size_t instance, NV::Rules::IMetric::ValueKind value_kind, double value) -> bool

        Parameters
        ----------
        instance: size_t
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: double

        """
        return _NvRules.IMutableMetric_set_double(self, *args)

    def set_uint64(self, *args):
        r"""
        set_uint64(IMutableMetric self, NV::Rules::IMetric::ValueKind value_kind, uint64_t value) -> bool

        Parameters
        ----------
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: uint64_t

        set_uint64(IMutableMetric self, size_t instance, NV::Rules::IMetric::ValueKind value_kind, uint64_t value) -> bool

        Parameters
        ----------
        instance: size_t
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: uint64_t

        """
        return _NvRules.IMutableMetric_set_uint64(self, *args)

    def set_string(self, *args):
        r"""
        set_string(IMutableMetric self, NV::Rules::IMetric::ValueKind value_kind, char const * value) -> bool

        Parameters
        ----------
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: char const *

        set_string(IMutableMetric self, size_t instance, NV::Rules::IMetric::ValueKind value_kind, char const * value) -> bool

        Parameters
        ----------
        instance: size_t
        value_kind: enum NV::Rules::IMetric::ValueKind
        value: char const *

        """
        return _NvRules.IMutableMetric_set_string(self, *args)

    def mutable_correlation_ids(self):
        r"""mutable_correlation_ids(IMutableMetric self) -> IMutableMetric"""
        return _NvRules.IMutableMetric_mutable_correlation_ids(self)

# Register IMutableMetric in _NvRules:
_NvRules.IMutableMetric_swigregister(IMutableMetric)
TableElementKind_INVALID = _NvRules.TableElementKind_INVALID

TableElementKind_DOUBLE = _NvRules.TableElementKind_DOUBLE

TableElementKind_INT = _NvRules.TableElementKind_INT

TableElementKind_STRING = _NvRules.TableElementKind_STRING

TableElementKind_CUSTOM = _NvRules.TableElementKind_CUSTOM

class TableSortInfo(object):
    r"""Proxy of C++ NV::Rules::TableSortInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    column = property(_NvRules.TableSortInfo_column_get, _NvRules.TableSortInfo_column_set, doc=r"""column : uint32_t""")
    is_ascending = property(_NvRules.TableSortInfo_is_ascending_get, _NvRules.TableSortInfo_is_ascending_set, doc=r"""is_ascending : bool""")

    def __init__(self):
        r"""__init__(TableSortInfo self) -> TableSortInfo"""
        _NvRules.TableSortInfo_swiginit(self, _NvRules.new_TableSortInfo())
    __swig_destroy__ = _NvRules.delete_TableSortInfo

# Register TableSortInfo in _NvRules:
_NvRules.TableSortInfo_swigregister(TableSortInfo)
class TableStyle(object):
    r"""Proxy of C++ NV::Rules::TableStyle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    is_bold = property(_NvRules.TableStyle_is_bold_get, _NvRules.TableStyle_is_bold_set, doc=r"""is_bold : bool""")
    is_italic = property(_NvRules.TableStyle_is_italic_get, _NvRules.TableStyle_is_italic_set, doc=r"""is_italic : bool""")

    def __init__(self):
        r"""__init__(TableStyle self) -> TableStyle"""
        _NvRules.TableStyle_swiginit(self, _NvRules.new_TableStyle())
    __swig_destroy__ = _NvRules.delete_TableStyle

# Register TableStyle in _NvRules:
_NvRules.TableStyle_swigregister(TableStyle)
class TableColumnConfig(object):
    r"""Proxy of C++ NV::Rules::TableColumnConfig class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    tooltip = property(_NvRules.TableColumnConfig_tooltip_get, _NvRules.TableColumnConfig_tooltip_set, doc=r"""tooltip : std::string""")
    relative_width = property(_NvRules.TableColumnConfig_relative_width_get, _NvRules.TableColumnConfig_relative_width_set, doc=r"""relative_width : double""")
    header_style = property(_NvRules.TableColumnConfig_header_style_get, _NvRules.TableColumnConfig_header_style_set, doc=r"""header_style : NV::Rules::TableStyle""")
    data_style = property(_NvRules.TableColumnConfig_data_style_get, _NvRules.TableColumnConfig_data_style_set, doc=r"""data_style : NV::Rules::TableStyle""")

    def __init__(self):
        r"""__init__(TableColumnConfig self) -> TableColumnConfig"""
        _NvRules.TableColumnConfig_swiginit(self, _NvRules.new_TableColumnConfig())
    __swig_destroy__ = _NvRules.delete_TableColumnConfig

# Register TableColumnConfig in _NvRules:
_NvRules.TableColumnConfig_swigregister(TableColumnConfig)
class TableConfig(object):
    r"""Proxy of C++ NV::Rules::TableConfig class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    title = property(_NvRules.TableConfig_title_get, _NvRules.TableConfig_title_set, doc=r"""title : std::string""")
    description = property(_NvRules.TableConfig_description_get, _NvRules.TableConfig_description_set, doc=r"""description : std::string""")
    use_sorting = property(_NvRules.TableConfig_use_sorting_get, _NvRules.TableConfig_use_sorting_set, doc=r"""use_sorting : bool""")
    sort_by = property(_NvRules.TableConfig_sort_by_get, _NvRules.TableConfig_sort_by_set, doc=r"""sort_by : NV::Rules::TableSortInfo""")
    use_styling = property(_NvRules.TableConfig_use_styling_get, _NvRules.TableConfig_use_styling_set, doc=r"""use_styling : bool""")
    style = property(_NvRules.TableConfig_style_get, _NvRules.TableConfig_style_set, doc=r"""style : NV::Rules::TableStyle""")

    def __init__(self):
        r"""__init__(TableConfig self) -> TableConfig"""
        _NvRules.TableConfig_swiginit(self, _NvRules.new_TableConfig())
    __swig_destroy__ = _NvRules.delete_TableConfig

# Register TableConfig in _NvRules:
_NvRules.TableConfig_swigregister(TableConfig)
class TableColumn(object):
    r"""Proxy of C++ NV::Rules::TableColumn class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_NvRules.TableColumn_name_get, _NvRules.TableColumn_name_set, doc=r"""name : std::string""")
    kind = property(_NvRules.TableColumn_kind_get, _NvRules.TableColumn_kind_set, doc=r"""kind : NV::Rules::TableElementKind""")
    double_values = property(_NvRules.TableColumn_double_values_get, _NvRules.TableColumn_double_values_set, doc=r"""double_values : std::vector<(double,std::allocator<(double)>)>""")
    int_values = property(_NvRules.TableColumn_int_values_get, _NvRules.TableColumn_int_values_set, doc=r"""int_values : std::vector<(long long,std::allocator<(long long)>)>""")
    string_values = property(_NvRules.TableColumn_string_values_get, _NvRules.TableColumn_string_values_set, doc=r"""string_values : std::vector<(std::string,std::allocator<(std::string)>)>""")
    has_column_config = property(_NvRules.TableColumn_has_column_config_get, _NvRules.TableColumn_has_column_config_set, doc=r"""has_column_config : bool""")
    column_config = property(_NvRules.TableColumn_column_config_get, _NvRules.TableColumn_column_config_set, doc=r"""column_config : NV::Rules::TableColumnConfig""")

    def size(self):
        r"""size(TableColumn self) -> uint64_t"""
        return _NvRules.TableColumn_size(self)

    def __init__(self):
        r"""__init__(TableColumn self) -> TableColumn"""
        _NvRules.TableColumn_swiginit(self, _NvRules.new_TableColumn())
    __swig_destroy__ = _NvRules.delete_TableColumn

# Register TableColumn in _NvRules:
_NvRules.TableColumn_swigregister(TableColumn)
class TableData(object):
    r"""Proxy of C++ NV::Rules::TableData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    columns = property(_NvRules.TableData_columns_get, _NvRules.TableData_columns_set, doc=r"""columns : std::vector<(NV::Rules::TableColumn,std::allocator<(NV::Rules::TableColumn)>)>""")
    has_config = property(_NvRules.TableData_has_config_get, _NvRules.TableData_has_config_set, doc=r"""has_config : bool""")
    config = property(_NvRules.TableData_config_get, _NvRules.TableData_config_set, doc=r"""config : NV::Rules::TableConfig""")

    def __init__(self):
        r"""__init__(TableData self) -> TableData"""
        _NvRules.TableData_swiginit(self, _NvRules.new_TableData())
    __swig_destroy__ = _NvRules.delete_TableData

# Register TableData in _NvRules:
_NvRules.TableData_swigregister(TableData)

def get_version(h):
    r"""
    get_version(NV::Rules::ContextHandle h) -> std::string

    Parameters
    ----------
    h: NV::Rules::ContextHandle

    """
    return _NvRules.get_version(h)

def get_context(h):
    r"""
    get_context(NV::Rules::ContextHandle h) -> IContext

    Parameters
    ----------
    h: NV::Rules::ContextHandle

    """
    return _NvRules.get_context(h)

def get_evaluator(h):
    r"""
    get_evaluator(NV::Rules::ContextHandle h) -> IEvaluator

    Parameters
    ----------
    h: NV::Rules::ContextHandle

    """
    return _NvRules.get_evaluator(h)

def raise_exception(h, msg):
    r"""
    raise_exception(NV::Rules::ContextHandle h, char const * msg)

    Parameters
    ----------
    h: NV::Rules::ContextHandle
    msg: char const *

    """
    return _NvRules.raise_exception(h, msg)
def ncu_report_add_method(cls, name):
    """This decorator allows us to add methods to already defined classes
    easily.

    For example, to add a method called `foo` to a class `Bar` you could use the
    following syntax:

       @ncu_report_add_method(Bar, 'foo')
       def name_is_not_important(self, param):
           do_something_with(self.baz, param)

    Note that the first parameter of the defined function will be treated like
    the `self` parameter when defining methods directly in classes.

    Also, the `name_is_not_important` function will still be usable with the
    first parameter being an object of the class you are adding the method to.
    """
    def decorator(func):
        setattr(cls, name, func)
        return func
    return decorator

@ncu_report_add_method(IContext, "__len__")
def IContext__len(ictx):
    """Get the number of IRange objects of this IContext.

    Returns:
        int: The number of IRange objects.

    """
    return ictx.num_ranges()


@ncu_report_add_method(IContext, "__getitem__")
def IContext__getitem(ictx, key):
    """Get one or more IRange objects by index or by slice.

    Args:
        key (int, slice): The index or slice to retrieve.

    Returns:
        An IRange object or a slice of IRange objects.

    Raises:
        TypeError: If `key` is not of type :obj:`int` or :obj:`slice`.
        IndexError: If `key` is out of range for the IContext.

    """
    _len = len(ictx)
    if isinstance(key, int):
        if key < -_len or key >= _len:
            raise IndexError("IContext index out of range")
        if key < 0:
            key += _len
        return ictx.range_by_idx(key)
    if isinstance(key, slice):
        return tuple(ictx[i] for i in range(*key.indices(_len)))
    raise TypeError(
        "IContext indices must be integers or slices, not {}".format(
            type(key).__name__
        )
    )


@ncu_report_add_method(IContext, "__iter__")
def IContext__iter(ictx):
    """Get an iterator over the IRange objects of this IContext.

    Returns:
        iterator: An iterator over the IRange objects.

    """
    return (ictx[i] for i in range(len(ictx)))

from abc import ABC, abstractmethod


class ConfigParser(ABC):
    @abstractmethod
    def parse(self, config: dict | None):
        pass


class StyleConfigParser(ConfigParser):
    STYLE_KEYS = ("bold", "italic")

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)

    def parse(self, config: dict | None):
        if config is None or not any(key in config for key in self.STYLE_KEYS):
            return None

        style_config = TableStyle()

        style_config.is_bold = config.get("bold", False)
        style_config.is_italic = config.get("italic", False)

        return style_config


class SortingConfigParser(ConfigParser):
    SORTING_KEYS = ("column", "order")

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)

    def _get_valid_column_index_or_raise(self, column, header):
        column_index = None
        column_name = None

        match column:
            case str():
                column_name = column
            case int():
                column_index = column
            case _:
                raise ValueError(
                    f"Unsupported type in \"sort_by\" for \"column\": {type(column)}"
                )

        if column_index is None:
            if column_name is not None:
                try:
                    column_index = header.index(column_name)
                except ValueError:
                    raise ValueError(f"Invalid column name in \"sort_by\": {column_name}")
            else:
                raise ValueError("No column specified in \"sort_by\"")

        if 0 <= column_index < len(header):
            return column_index

        raise ValueError(f"Invalid column index in \"sort_by\": {column_index}")

    def _get_is_ascending_or_raise(self, order_keyword):
        match order_keyword.lower():
            case "ascending":
                return True
            case "descending":
                return False
            case _:
                raise ValueError(
                    f"Invalid order keyword in \"sort_by\": {order_keyword}."
                    " Allowed values are \"ascending\" and \"descending\"."
                )

    def parse(self, config: dict | None, header: list[str]):
        if config is None or not any(key in config for key in self.SORTING_KEYS):
            return None

        sorting_config = TableSortInfo()

# Specification of column to sort by is mandatory
        if "column" in config:
            column_index = self._get_valid_column_index_or_raise(config["column"], header)
        else:
            raise ValueError("No column specified in \"sort_by\"")

# Order defaults to ascending
        ascending = True
        if "order" in config:
            ascending = self._get_is_ascending_or_raise(config["order"])

        sorting_config.column = column_index
        sorting_config.is_ascending = ascending

        return sorting_config


class ColumnLevelConfigParser(ConfigParser):
    COLUMN_LEVEL_KEYS = ("tooltip", "relative_width", "style")

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)

    def parse(self, config: dict | None):
        if config is None or not any(key in config for key in self.COLUMN_LEVEL_KEYS):
            return None

        column_config = TableColumnConfig()

        if "tooltip" in config:
            column_config.tooltip = config["tooltip"]
        if "relative_width" in config:
            column_config.relative_width = config["relative_width"]
        if "style" in config:
            if "header" in config["style"]:
                header_style_config = StyleConfigParser().parse(config["style"]["header"])
                if header_style_config is not None:
                    column_config.header_style = header_style_config
            if "data" in config["style"]:
                data_style_config = StyleConfigParser().parse(config["style"]["data"])
                if data_style_config is not None:
                    column_config.data_style = data_style_config

        return column_config


class GlobalLevelConfigParser(ConfigParser):
    GLOBAL_LEVEL_KEYS = ("title", "description", "sort_by", "style")

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)

    def parse(self, config: dict | None, header: list[str]):
        if config is None or not any(key in config for key in self.GLOBAL_LEVEL_KEYS):
            return None

        table_config = TableConfig()

        if "title" in config:
            table_config.title = config["title"]
        if "description" in config:
            table_config.description = config["description"]
        if "sort_by" in config:
            sort_config = SortingConfigParser().parse(config["sort_by"], header)
            if sort_config is not None:
                table_config.use_sorting = True
                table_config.sort_by = sort_config
        if "style" in config:
            style_config = StyleConfigParser().parse(config["style"])
            if style_config is not None:
                table_config.use_styling = True
                table_config.style = style_config

        return table_config


def _transpose_table_data(data_by_row):
    if len(data_by_row) == 0:
        raise ValueError("No rows in data")

    num_columns = len(data_by_row[0])
    if num_columns == 0:
        raise ValueError("No columns in first row of data")

    for id, row in enumerate(data_by_row):
        current_num_columns = len(row)
        if current_num_columns != num_columns:
            raise ValueError(
                f"Row {id} has different length ({current_num_columns})"
                f" than first row ({num_columns})"
            )

    return list(map(list, zip(*data_by_row)))


def _convert_data_to_backend_format(header, data_by_column, config):
    if len(header) == 0:
        raise ValueError("No columns in header")

    if len(header) != len(data_by_column):
        raise ValueError(
            f"Number of columns in header ({len(header)}) does not match"
            f" number of columns in data ({len(data_by_column)})"
        )

    for col_id, column in enumerate(data_by_column):
        first_element = column[0]
        for row_id, element in enumerate(column):
            if type(element) is not type(first_element):
                raise TypeError(
                    f"Column {col_id} has mixed types:"
                    f" {type(element)} (row {row_id}) and"
                    f" {type(first_element)} (row 0)"
                )

    data_backend = TableData()

# fill global config
    table_config = GlobalLevelConfigParser().parse(config, header)
    if table_config is not None:
        data_backend.has_config = True
        data_backend.config = table_config

# fill columns
    for column_id, (column_name, column_data) in enumerate(zip(header, data_by_column)):
        column_backend = TableColumn()
        column_backend.name = column_name

# set column kind and values
        first_element = column_data[0]
        match first_element:
            case int():
                column_backend.kind = TableElementKind_INT
                column_backend.int_values = vector_longlong(column_data)
            case float():
                column_backend.kind = TableElementKind_DOUBLE
                column_backend.double_values = vector_double(column_data)
            case str():
                column_backend.kind = TableElementKind_STRING
                column_backend.string_values = vector_string(column_data)
            case _:
                try:
                    column_backend.kind = TableElementKind_CUSTOM
                    column_values = [str(value) for value in column_data]
                except Exception:
                    column_backend.kind = TableElementKind_INVALID
                    column_values = ["???"] * len(column_data)
                finally:
                    column_backend.string_values = vector_string(column_values)

# set column config
        if config is not None and "per_column_configs" in config:
            per_column_config = config["per_column_configs"].get(column_name, None) or \
                config["per_column_configs"].get(column_id, None)
            column_config = ColumnLevelConfigParser().parse(per_column_config)
            if column_config is not None:
                column_backend.has_column_config = True
                column_backend.column_config = column_config

        data_backend.columns.append(column_backend)

    return data_backend


@ncu_report_add_method(IFrontend, "generate_table")
def IFrontend_generate_table_impl(self, message_id, header, data, config=None):
    """Generate a table in the frontend.

    This function attaches a table to the pre-existing rule message given by `message_id`.
    It can be called multiple times to attach multiple tables to the same message.

    The table can be customized by passing a `dict` to the `config` parameter.
    The table can contain a title, description, a column to sort by, and a global styling.
    Additionally, the table can have per-column configurations, which can specify
    a header tooltip, relative column width, and styling for the header and data cells.

    This is an example of a valid `config` `dict`:

        config = {
            "title": "My table title",
            "description": "Short description of the table",
            "sort_by": {
                "column": "MyColumn",  # specify column by name or index
                "order": "ascending",  # in ascending order (default)
            },
            "per_column_configs": {  # overwrites global styling for individual columns
                "MyColumn": {  # can use column name or index
                    "tooltip": "Explanation of MyColumn",  # tooltip for the header
                    "relative_width": 0.5,  # relative width of the column
                    "style": {
                        "header": {"bold": True},
                        "data": {"italic": True},
                    }
                },
            },
        }

    Args:
        message_id (int): The message to which to attach the table to.
        header (list[str]): The column labels of the table.
        data (list[list[int | float | str | Any]]): The table data in row-major format.
            `Any` refers to any type that implements `__str__`.
            Each column must only have elements of the same type,
            and all columns must have the same length.
        config (dict[str, Any] | None): Configuration options for the table.
            Defaults to None.

    Raises:
        TypeError: If types of elements within a column are mixed.
        ValueError: If columns have different lengths, or len(header) does not match
            the number of columns in data.
    """
    data_by_column = _transpose_table_data(data)
    data_backend = _convert_data_to_backend_format(header, data_by_column, config)
    self._generate_table(message_id, data_backend)

@ncu_report_add_method(IRange, "__len__")
def IRange__len(irange):
    """Get the number of IAction objects of this IRange.

    Returns:
        int: The number of IAction objects.

    """
    return irange.num_actions()


@ncu_report_add_method(IRange, "__getitem__")
def IRange__getitem(irange, key):
    """Get one or more IAction objects by index or by slice.

    Args:
        key (int, slice): The index or slice to retrieve.

    Returns:
        An IAction object or a slice of IAction objects.

    Raises:
        TypeError: If `key` is not of type :obj:`int` or :obj:`slice`.
        IndexError: If `key` is out of range for the IContext.

    """
    _len = len(irange)
    if isinstance(key, int):
        if key < -_len or key >= _len:
            raise IndexError("IRange index out of range")
        if key < 0:
            key += _len
        return irange.action_by_idx(key)
    if isinstance(key, slice):
        return tuple(irange[i] for i in range(*key.indices(_len)))
    raise TypeError(
        "IRange indices must be integers or slices, not {}".format(
            type(key).__name__
        )
    )


@ncu_report_add_method(IRange, "__iter__")
def IRange__iter(irange):
    """Get an iterator over the IAction objects of this IRange.

    Returns:
        iterator: An iterator over the IAction objects.

    """
    return (irange[i] for i in range(len(irange)))

@ncu_report_add_method(IAction, "__str__")
def IAction__str(iaction):
    """Get a human-readable representation of this IAction.

    Returns:
        str: The name of the kernel the IAction object represents.

    """
    return iaction.name()


@ncu_report_add_method(IAction, "__len__")
def IAction__len(iaction):
    """Get the number of IMetric objects of this IAction.

    Returns:
        int: The number of IMetric objects.

    """
    return len(iaction.metric_names())


@ncu_report_add_method(IAction, "__iter__")
def IAction__iter(iaction):
    """Get an iterator over the metric names of this IAction.

    Returns:
        iterator: An iterator over the metric names.

    """
    return iter(iaction.metric_names())


@ncu_report_add_method(IAction, "__getitem__")
def IAction__getitem(iaction, key):
    """Get an IMetric object contained in this IAction by its name.

    Args:
        key (str): The name of the IMetric object to retrieve.

    Returns:
        :obj:`IMetric`: An IMetric object.

    Raises:
        TypeError: If `key` is not of type :obj:`str`.
        KeyError: If `key` is not the name of any IMetric object.

    """
    if not isinstance(key, str):
        raise TypeError(
            "IAction metric keys must be strings, not {}".format(type(key).__name__)
        )

    metric = iaction.metric_by_name(key)

    if metric is None:
        raise KeyError("no metric named '{}'".format(key))

    return metric

IMetric_kind_to_value_func = {
    IMetric.ValueKind_ANY: lambda *args: None,
    IMetric.ValueKind_DOUBLE: IMetric.as_double,
    IMetric.ValueKind_FLOAT: IMetric.as_double,
    IMetric.ValueKind_STRING: IMetric.as_string,
    IMetric.ValueKind_UINT32: IMetric.as_uint64,
    IMetric.ValueKind_UINT64: IMetric.as_uint64,
    IMetric.ValueKind_UNKNOWN: lambda *args: None,
}


@ncu_report_add_method(IMetric, "__str__")
def IMetric__str(imetric):
    """Get a human-readable representation of this IMetric.

    Returns:
        str: The name of the IMetric.

    """
    return imetric.name()


@ncu_report_add_method(IMetric, "value")
def IMetric__value(imetric, idx=None):
    """Get the value of this IMetric.

    Args:
        idx (:obj:`int`, optional): The index of the correlation ids. Defaults to None.

    Returns:
        The value of this IMetric as str, int or float.

    """
    args = tuple() if idx is None else (idx,)
    return IMetric_kind_to_value_func[imetric.kind(*args)](imetric, *args)


def IMetric__metric_subtype_using_None(member_func):
    def IMetric__metric_subtype(imetric):
        """Get the subtype of this IMetric.

        Returns:
            int: The subtype of this IMetric, if applicable, None otherwise.

        """
        subtype = member_func(imetric)
        if subtype == imetric.MetricSubtype_NONE:
            return None
        else:
            return subtype
    return IMetric__metric_subtype

wrapped_metric_subtype = IMetric__metric_subtype_using_None(IMetric.metric_subtype)
setattr(IMetric, "metric_subtype", wrapped_metric_subtype)


def IMetric__rollup_operation_using_None(member_func):
    def IMetric__rollup_operation(imetric):
        """Get the rollup operation of this IMetric.

        Returns:
            int, None: The rollup operation of this IMetric, if applicable,
                None otherwise.

        """
        rollup_op = member_func(imetric)
        if rollup_op == imetric.RollupOperation_NONE:
            return None
        else:
            return rollup_op
    return IMetric__rollup_operation

wrapped_rollup_operation = IMetric__rollup_operation_using_None(IMetric.rollup_operation)
setattr(IMetric, "rollup_operation", wrapped_rollup_operation)

@ncu_report_add_method(INvtxState, "__len__")
def INvtxState__len(invtx_state):
    """Get the number of INvtxDomainInfo objects of this INvtxState.

    Returns:
        int: The number of INvtxDomainInfo objects.

    """
    return len(invtx_state.domains())


@ncu_report_add_method(INvtxState, "__iter__")
def INvtxState__iter(invtx_state):
    """Get an iterator over the INvtxDomainInfo objects of this INvtxState.

    Returns:
        iterator: An iterator over the INvtxDomainInfo objects.

    """
    return iter(invtx_state.domains())


@ncu_report_add_method(INvtxState, "__getitem__")
def INvtxState__getitem(invtx_state, key):
    """Get an INvtxDomainInfo object by ID.

    Args:
        key (int): The ID of the INvtxDomainInfo object.

    Returns:
        :obj:`INvtxDomainInfo`: An INvtxDomainInfo object.

    Raises:
        TypeError: If `key` is not of type :obj:`int`.
        KeyError: If `key` is not a valid ID.

    """
    if isinstance(key, int):
        if key not in invtx_state.domains():
            raise KeyError("INvtxState invalid ID")
        return invtx_state.domain_by_id(key)
    raise TypeError(
        "INvtxState IDs must be integers, not {}".format(
            type(key).__name__
        )
    )

@ncu_report_add_method(INvtxDomainInfo, "__str__")
def INvtxDomainInfo__str(invtx_domain):
    """Get a human-readable representation of this INvtxDomainInfo.

    Returns:
        str: The name of the INvtxDomainInfo.

    """
    return invtx_domain.name()