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





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_apol', [dirname(__file__)])
        except ImportError:
            import _apol
            return _apol
        if fp is not None:
            try:
                _mod = imp.load_module('_apol', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _apol = swig_import_helper()
    del swig_import_helper
else:
    import _apol
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


import qpol

_apol.APOL_QUERY_SUB_swigconstant(_apol)
APOL_QUERY_SUB = _apol.APOL_QUERY_SUB

_apol.APOL_QUERY_SUPER_swigconstant(_apol)
APOL_QUERY_SUPER = _apol.APOL_QUERY_SUPER

_apol.APOL_QUERY_EXACT_swigconstant(_apol)
APOL_QUERY_EXACT = _apol.APOL_QUERY_EXACT

_apol.APOL_QUERY_INTERSECT_swigconstant(_apol)
APOL_QUERY_INTERSECT = _apol.APOL_QUERY_INTERSECT

_apol.APOL_QUERY_FLAGS_swigconstant(_apol)
APOL_QUERY_FLAGS = _apol.APOL_QUERY_FLAGS

_apol.APOL_QUERY_SYMBOL_IS_TYPE_swigconstant(_apol)
APOL_QUERY_SYMBOL_IS_TYPE = _apol.APOL_QUERY_SYMBOL_IS_TYPE

_apol.APOL_QUERY_SYMBOL_IS_ATTRIBUTE_swigconstant(_apol)
APOL_QUERY_SYMBOL_IS_ATTRIBUTE = _apol.APOL_QUERY_SYMBOL_IS_ATTRIBUTE

def libapol_get_version():
    return _apol.libapol_get_version()
libapol_get_version = _apol.libapol_get_version

def apol_protocol_to_str(protocol):
    return _apol.apol_protocol_to_str(protocol)
apol_protocol_to_str = _apol.apol_protocol_to_str

def apol_str_to_protocol(protocol_str):
    return _apol.apol_str_to_protocol(protocol_str)
apol_str_to_protocol = _apol.apol_str_to_protocol
class apol_ip_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_ip_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_ip_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ip"] = _apol.apol_ip_t_ip_set
    __swig_getmethods__["ip"] = _apol.apol_ip_t_ip_get
    if _newclass:
        ip = _swig_property(_apol.apol_ip_t_ip_get, _apol.apol_ip_t_ip_set)
    __swig_setmethods__["proto"] = _apol.apol_ip_t_proto_set
    __swig_getmethods__["proto"] = _apol.apol_ip_t_proto_get
    if _newclass:
        proto = _swig_property(_apol.apol_ip_t_proto_get, _apol.apol_ip_t_proto_set)

    def __init__(self, str):
        this = _apol.new_apol_ip_t(str)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_ip_t
    __del__ = lambda self: None

    def get_protocol(self):
        return _apol.apol_ip_t_get_protocol(self)
apol_ip_t_swigregister = _apol.apol_ip_t_swigregister
apol_ip_t_swigregister(apol_ip_t)


def apol_str_to_internal_ip(str):
    return _apol.apol_str_to_internal_ip(str)
apol_str_to_internal_ip = _apol.apol_str_to_internal_ip

def apol_objclass_to_str(objclass):
    return _apol.apol_objclass_to_str(objclass)
apol_objclass_to_str = _apol.apol_objclass_to_str

def apol_str_to_objclass(objclass):
    return _apol.apol_str_to_objclass(objclass)
apol_str_to_objclass = _apol.apol_str_to_objclass

def apol_fs_use_behavior_to_str(behavior):
    return _apol.apol_fs_use_behavior_to_str(behavior)
apol_fs_use_behavior_to_str = _apol.apol_fs_use_behavior_to_str

def apol_str_to_fs_use_behavior(behavior):
    return _apol.apol_str_to_fs_use_behavior(behavior)
apol_str_to_fs_use_behavior = _apol.apol_str_to_fs_use_behavior

def apol_rule_type_to_str(rule_type):
    return _apol.apol_rule_type_to_str(rule_type)
apol_rule_type_to_str = _apol.apol_rule_type_to_str

def apol_cond_expr_type_to_str(expr_type):
    return _apol.apol_cond_expr_type_to_str(expr_type)
apol_cond_expr_type_to_str = _apol.apol_cond_expr_type_to_str

def apol_file_find_path(file_name):
    return _apol.apol_file_find_path(file_name)
apol_file_find_path = _apol.apol_file_find_path

def apol_ipv4_addr_render(p, addr):
    return _apol.apol_ipv4_addr_render(p, addr)
apol_ipv4_addr_render = _apol.apol_ipv4_addr_render

def apol_ipv6_addr_render(p, addr):
    return _apol.apol_ipv6_addr_render(p, addr)
apol_ipv6_addr_render = _apol.apol_ipv6_addr_render

def apol_qpol_context_render(p, context):
    return _apol.apol_qpol_context_render(p, context)
apol_qpol_context_render = _apol.apol_qpol_context_render
class apol_vector_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_vector_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_vector_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_vector_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_size(self):
        return _apol.apol_vector_t_get_size(self)

    def get_capacity(self):
        return _apol.apol_vector_t_get_capacity(self)

    def get_element(self, i):
        return _apol.apol_vector_t_get_element(self, i)
    __swig_destroy__ = _apol.delete_apol_vector_t
    __del__ = lambda self: None

    def append(self, x):
        return _apol.apol_vector_t_append(self, x)

    def append_unique(self, x):
        return _apol.apol_vector_t_append_unique(self, x)

    def cat(self, src):
        return _apol.apol_vector_t_cat(self, src)

    def remove(self, idx):
        return _apol.apol_vector_t_remove(self, idx)

    def sort(self):
        return _apol.apol_vector_t_sort(self)

    def sort_uniquify(self):
        return _apol.apol_vector_t_sort_uniquify(self)
apol_vector_t_swigregister = _apol.apol_vector_t_swigregister
apol_vector_t_swigregister(apol_vector_t)


def apol_vector_compare(a, b):
    return _apol.apol_vector_compare(a, b)
apol_vector_compare = _apol.apol_vector_compare
class apol_string_vector_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_string_vector_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_string_vector_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_string_vector_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_size(self):
        return _apol.apol_string_vector_t_get_size(self)

    def get_capacity(self):
        return _apol.apol_string_vector_t_get_capacity(self)

    def get_element(self, i):
        return _apol.apol_string_vector_t_get_element(self, i)
    __swig_destroy__ = _apol.delete_apol_string_vector_t
    __del__ = lambda self: None

    def get_index(self, str):
        return _apol.apol_string_vector_t_get_index(self, str)

    def append(self, str):
        return _apol.apol_string_vector_t_append(self, str)

    def append_unique(self, str):
        return _apol.apol_string_vector_t_append_unique(self, str)

    def cat(self, src):
        return _apol.apol_string_vector_t_cat(self, src)

    def remove(self, idx):
        return _apol.apol_string_vector_t_remove(self, idx)

    def sort(self):
        return _apol.apol_string_vector_t_sort(self)

    def sort_uniquify(self):
        return _apol.apol_string_vector_t_sort_uniquify(self)
apol_string_vector_t_swigregister = _apol.apol_string_vector_t_swigregister
apol_string_vector_t_swigregister(apol_string_vector_t)


_apol.APOL_POLICY_PATH_TYPE_MONOLITHIC_swigconstant(_apol)
APOL_POLICY_PATH_TYPE_MONOLITHIC = _apol.APOL_POLICY_PATH_TYPE_MONOLITHIC

_apol.APOL_POLICY_PATH_TYPE_MODULAR_swigconstant(_apol)
APOL_POLICY_PATH_TYPE_MODULAR = _apol.APOL_POLICY_PATH_TYPE_MODULAR
class apol_policy_path_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_policy_path_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_policy_path_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_policy_path_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_policy_path_t
    __del__ = lambda self: None

    def get_type(self):
        return _apol.apol_policy_path_t_get_type(self)

    def get_primary(self):
        return _apol.apol_policy_path_t_get_primary(self)

    def get_modules(self):
        return _apol.apol_policy_path_t_get_modules(self)

    def to_string(self):
        return _apol.apol_policy_path_t_to_string(self)

    def to_file(self, path):
        return _apol.apol_policy_path_t_to_file(self, path)
apol_policy_path_t_swigregister = _apol.apol_policy_path_t_swigregister
apol_policy_path_t_swigregister(apol_policy_path_t)


def apol_policy_path_compare(a, b):
    return _apol.apol_policy_path_compare(a, b)
apol_policy_path_compare = _apol.apol_policy_path_compare

def apol_file_is_policy_path_list(filename):
    return _apol.apol_file_is_policy_path_list(filename)
apol_file_is_policy_path_list = _apol.apol_file_is_policy_path_list
class apol_policy_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_policy_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_policy_t, name)
    __repr__ = _swig_repr

    def __init__(self, path, options=0):
        this = _apol.new_apol_policy_t(path, options)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_policy_t
    __del__ = lambda self: None

    def get_policy_type(self):
        return _apol.apol_policy_t_get_policy_type(self)

    def get_policy_handle_unknown(self):
        return _apol.apol_policy_t_get_policy_handle_unknown(self)

    def get_qpol(self):
        return _apol.apol_policy_t_get_qpol(self)

    def is_mls(self):
        return _apol.apol_policy_t_is_mls(self)

    def get_version_type_mls_str(self):
        return _apol.apol_policy_t_get_version_type_mls_str(self)

    def open_permmap(self, path):
        return _apol.apol_policy_t_open_permmap(self, path)

    def save_permmap(self, path):
        return _apol.apol_policy_t_save_permmap(self, path)

    def get_permmap_weight(self, class_name, perm_name):
        return _apol.apol_policy_t_get_permmap_weight(self, class_name, perm_name)

    def get_permmap_direction(self, class_name, perm_name):
        return _apol.apol_policy_t_get_permmap_direction(self, class_name, perm_name)

    def set_permmap(self, class_name, perm_name, direction, weight):
        return _apol.apol_policy_t_set_permmap(self, class_name, perm_name, direction, weight)

    def build_domain_trans_table(self):
        return _apol.apol_policy_t_build_domain_trans_table(self)

    def reset_domain_trans_table(self):
        return _apol.apol_policy_t_reset_domain_trans_table(self)
apol_policy_t_swigregister = _apol.apol_policy_t_swigregister
apol_policy_t_swigregister(apol_policy_t)


_apol.APOL_PERMMAP_MAX_WEIGHT_swigconstant(_apol)
APOL_PERMMAP_MAX_WEIGHT = _apol.APOL_PERMMAP_MAX_WEIGHT

_apol.APOL_PERMMAP_MIN_WEIGHT_swigconstant(_apol)
APOL_PERMMAP_MIN_WEIGHT = _apol.APOL_PERMMAP_MIN_WEIGHT

_apol.APOL_PERMMAP_UNMAPPED_swigconstant(_apol)
APOL_PERMMAP_UNMAPPED = _apol.APOL_PERMMAP_UNMAPPED

_apol.APOL_PERMMAP_READ_swigconstant(_apol)
APOL_PERMMAP_READ = _apol.APOL_PERMMAP_READ

_apol.APOL_PERMMAP_WRITE_swigconstant(_apol)
APOL_PERMMAP_WRITE = _apol.APOL_PERMMAP_WRITE

_apol.APOL_PERMMAP_BOTH_swigconstant(_apol)
APOL_PERMMAP_BOTH = _apol.APOL_PERMMAP_BOTH

_apol.APOL_PERMMAP_NONE_swigconstant(_apol)
APOL_PERMMAP_NONE = _apol.APOL_PERMMAP_NONE
class apol_type_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_type_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_type_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_type_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_type_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_type_query_t_run(self, p)

    def set_type(self, p, name):
        return _apol.apol_type_query_t_set_type(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_type_query_t_set_regex(self, p, regex)
apol_type_query_t_swigregister = _apol.apol_type_query_t_swigregister
apol_type_query_t_swigregister(apol_type_query_t)

class apol_attr_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_attr_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_attr_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_attr_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_attr_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_attr_query_t_run(self, p)

    def set_attr(self, p, name):
        return _apol.apol_attr_query_t_set_attr(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_attr_query_t_set_regex(self, p, regex)
apol_attr_query_t_swigregister = _apol.apol_attr_query_t_swigregister
apol_attr_query_t_swigregister(apol_attr_query_t)

class apol_role_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_role_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_role_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_role_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_role_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_role_query_t_run(self, p)

    def set_role(self, p, name):
        return _apol.apol_role_query_t_set_role(self, p, name)

    def set_type(self, p, name):
        return _apol.apol_role_query_t_set_type(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_role_query_t_set_regex(self, p, regex)
apol_role_query_t_swigregister = _apol.apol_role_query_t_swigregister
apol_role_query_t_swigregister(apol_role_query_t)


def apol_role_has_type(p, r, t):
    return _apol.apol_role_has_type(p, r, t)
apol_role_has_type = _apol.apol_role_has_type
class apol_class_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_class_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_class_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_class_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_class_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_class_query_t_run(self, p)

    def set_class(self, p, name):
        return _apol.apol_class_query_t_set_class(self, p, name)

    def set_common(self, p, name):
        return _apol.apol_class_query_t_set_common(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_class_query_t_set_regex(self, p, regex)
apol_class_query_t_swigregister = _apol.apol_class_query_t_swigregister
apol_class_query_t_swigregister(apol_class_query_t)

class apol_common_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_common_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_common_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_common_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_common_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_common_query_t_run(self, p)

    def set_common(self, p, name):
        return _apol.apol_common_query_t_set_common(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_common_query_t_set_regex(self, p, regex)
apol_common_query_t_swigregister = _apol.apol_common_query_t_swigregister
apol_common_query_t_swigregister(apol_common_query_t)

class apol_perm_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_perm_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_perm_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_perm_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_perm_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_perm_query_t_run(self, p)

    def set_perm(self, p, name):
        return _apol.apol_perm_query_t_set_perm(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_perm_query_t_set_regex(self, p, regex)
apol_perm_query_t_swigregister = _apol.apol_perm_query_t_swigregister
apol_perm_query_t_swigregister(apol_perm_query_t)

class apol_bool_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_bool_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_bool_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_bool_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_bool_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_bool_query_t_run(self, p)

    def set_bool(self, p, name):
        return _apol.apol_bool_query_t_set_bool(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_bool_query_t_set_regex(self, p, regex)
apol_bool_query_t_swigregister = _apol.apol_bool_query_t_swigregister
apol_bool_query_t_swigregister(apol_bool_query_t)

class apol_mls_level_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_mls_level_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_mls_level_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_mls_level_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_mls_level_t
    __del__ = lambda self: None

    def set_sens(self, p, sens):
        return _apol.apol_mls_level_t_set_sens(self, p, sens)

    def get_sens(self):
        return _apol.apol_mls_level_t_get_sens(self)

    def append_cats(self, p, cats):
        return _apol.apol_mls_level_t_append_cats(self, p, cats)

    def get_cats(self):
        return _apol.apol_mls_level_t_get_cats(self)

    def validate(self, p):
        return _apol.apol_mls_level_t_validate(self, p)

    def render(self, p):
        return _apol.apol_mls_level_t_render(self, p)

    def convert(self, p):
        return _apol.apol_mls_level_t_convert(self, p)

    def is_literal(self):
        return _apol.apol_mls_level_t_is_literal(self)
apol_mls_level_t_swigregister = _apol.apol_mls_level_t_swigregister
apol_mls_level_t_swigregister(apol_mls_level_t)


_apol.APOL_MLS_EQ_swigconstant(_apol)
APOL_MLS_EQ = _apol.APOL_MLS_EQ

_apol.APOL_MLS_DOM_swigconstant(_apol)
APOL_MLS_DOM = _apol.APOL_MLS_DOM

_apol.APOL_MLS_DOMBY_swigconstant(_apol)
APOL_MLS_DOMBY = _apol.APOL_MLS_DOMBY

_apol.APOL_MLS_INCOMP_swigconstant(_apol)
APOL_MLS_INCOMP = _apol.APOL_MLS_INCOMP

def apol_mls_level_compare(p, level1, level2):
    return _apol.apol_mls_level_compare(p, level1, level2)
apol_mls_level_compare = _apol.apol_mls_level_compare

def apol_mls_sens_compare(p, sens1, sens2):
    return _apol.apol_mls_sens_compare(p, sens1, sens2)
apol_mls_sens_compare = _apol.apol_mls_sens_compare

def apol_mls_cats_compare(p, cat1, cat2):
    return _apol.apol_mls_cats_compare(p, cat1, cat2)
apol_mls_cats_compare = _apol.apol_mls_cats_compare

def apol_mls_level_from_void(x):
    return _apol.apol_mls_level_from_void(x)
apol_mls_level_from_void = _apol.apol_mls_level_from_void
class apol_mls_range_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_mls_range_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_mls_range_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_mls_range_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_mls_range_t
    __del__ = lambda self: None

    def set_low(self, p, lvl):
        return _apol.apol_mls_range_t_set_low(self, p, lvl)

    def set_high(self, p, lvl):
        return _apol.apol_mls_range_t_set_high(self, p, lvl)

    def get_low(self):
        return _apol.apol_mls_range_t_get_low(self)

    def get_high(self):
        return _apol.apol_mls_range_t_get_high(self)

    def render(self, p):
        return _apol.apol_mls_range_t_render(self, p)

    def get_levels(self, p):
        return _apol.apol_mls_range_t_get_levels(self, p)

    def validate(self, p):
        return _apol.apol_mls_range_t_validate(self, p)

    def is_literal(self):
        return _apol.apol_mls_range_t_is_literal(self)

    def convert(self, p):
        return _apol.apol_mls_range_t_convert(self, p)
apol_mls_range_t_swigregister = _apol.apol_mls_range_t_swigregister
apol_mls_range_t_swigregister(apol_mls_range_t)


def apol_mls_range_compare(p, target, search, range_compare_type):
    return _apol.apol_mls_range_compare(p, target, search, range_compare_type)
apol_mls_range_compare = _apol.apol_mls_range_compare

def apol_mls_range_contain_subrange(p, range, subrange):
    return _apol.apol_mls_range_contain_subrange(p, range, subrange)
apol_mls_range_contain_subrange = _apol.apol_mls_range_contain_subrange

def apol_mls_range_from_void(x):
    return _apol.apol_mls_range_from_void(x)
apol_mls_range_from_void = _apol.apol_mls_range_from_void
class apol_level_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_level_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_level_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_level_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_level_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_level_query_t_run(self, p)

    def set_sens(self, p, name):
        return _apol.apol_level_query_t_set_sens(self, p, name)

    def set_cat(self, p, name):
        return _apol.apol_level_query_t_set_cat(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_level_query_t_set_regex(self, p, regex)
apol_level_query_t_swigregister = _apol.apol_level_query_t_swigregister
apol_level_query_t_swigregister(apol_level_query_t)

class apol_cat_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_cat_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_cat_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_cat_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_cat_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_cat_query_t_run(self, p)

    def set_cat(self, p, name):
        return _apol.apol_cat_query_t_set_cat(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_cat_query_t_set_regex(self, p, regex)
apol_cat_query_t_swigregister = _apol.apol_cat_query_t_swigregister
apol_cat_query_t_swigregister(apol_cat_query_t)

class apol_user_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_user_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_user_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_user_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_user_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_user_query_t_run(self, p)

    def set_user(self, p, name):
        return _apol.apol_user_query_t_set_user(self, p, name)

    def set_role(self, p, name):
        return _apol.apol_user_query_t_set_role(self, p, name)

    def set_default_level(self, p, lvl):
        return _apol.apol_user_query_t_set_default_level(self, p, lvl)

    def set_range(self, p, rng, range_match):
        return _apol.apol_user_query_t_set_range(self, p, rng, range_match)

    def set_regex(self, p, regex):
        return _apol.apol_user_query_t_set_regex(self, p, regex)
apol_user_query_t_swigregister = _apol.apol_user_query_t_swigregister
apol_user_query_t_swigregister(apol_user_query_t)

class apol_context_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_context_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_context_t, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _apol.new_apol_context_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_context_t
    __del__ = lambda self: None

    def set_user(self, p, name):
        return _apol.apol_context_t_set_user(self, p, name)

    def get_user(self):
        return _apol.apol_context_t_get_user(self)

    def set_role(self, p, name):
        return _apol.apol_context_t_set_role(self, p, name)

    def get_role(self):
        return _apol.apol_context_t_get_role(self)

    def set_type(self, p, name):
        return _apol.apol_context_t_set_type(self, p, name)

    def get_type(self):
        return _apol.apol_context_t_get_type(self)

    def set_range(self, p, rng):
        return _apol.apol_context_t_set_range(self, p, rng)

    def get_range(self):
        return _apol.apol_context_t_get_range(self)

    def validate(self, p):
        return _apol.apol_context_t_validate(self, p)

    def validate_partial(self, p):
        return _apol.apol_context_t_validate_partial(self, p)

    def render(self, p):
        return _apol.apol_context_t_render(self, p)

    def convert(self, p):
        return _apol.apol_context_t_convert(self, p)
apol_context_t_swigregister = _apol.apol_context_t_swigregister
apol_context_t_swigregister(apol_context_t)


def apol_context_compare(p, target, search, range_compare_type):
    return _apol.apol_context_compare(p, target, search, range_compare_type)
apol_context_compare = _apol.apol_context_compare
class apol_constraint_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_constraint_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_constraint_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_constraint_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_constraint_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_constraint_query_t_run(self, p)

    def set_class(self, p, name):
        return _apol.apol_constraint_query_t_set_class(self, p, name)

    def set_perm(self, p, name):
        return _apol.apol_constraint_query_t_set_perm(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_constraint_query_t_set_regex(self, p, regex)
apol_constraint_query_t_swigregister = _apol.apol_constraint_query_t_swigregister
apol_constraint_query_t_swigregister(apol_constraint_query_t)

class apol_validatetrans_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_validatetrans_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_validatetrans_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_validatetrans_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_validatetrans_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_validatetrans_query_t_run(self, p)

    def set_class(self, p, name):
        return _apol.apol_validatetrans_query_t_set_class(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_validatetrans_query_t_set_regex(self, p, regex)
apol_validatetrans_query_t_swigregister = _apol.apol_validatetrans_query_t_swigregister
apol_validatetrans_query_t_swigregister(apol_validatetrans_query_t)

class apol_genfscon_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_genfscon_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_genfscon_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_genfscon_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_genfscon_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_genfscon_query_t_run(self, p)

    def set_filesystem(self, p, fs):
        return _apol.apol_genfscon_query_t_set_filesystem(self, p, fs)

    def set_path(self, p, path):
        return _apol.apol_genfscon_query_t_set_path(self, p, path)

    def set_objclass(self, p, objclass):
        return _apol.apol_genfscon_query_t_set_objclass(self, p, objclass)

    def set_context(self, p, ctx, range_match):
        return _apol.apol_genfscon_query_t_set_context(self, p, ctx, range_match)
apol_genfscon_query_t_swigregister = _apol.apol_genfscon_query_t_swigregister
apol_genfscon_query_t_swigregister(apol_genfscon_query_t)


def apol_genfscon_render(p, genfscon):
    return _apol.apol_genfscon_render(p, genfscon)
apol_genfscon_render = _apol.apol_genfscon_render
class apol_fs_use_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_fs_use_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_fs_use_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_fs_use_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_fs_use_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_fs_use_query_t_run(self, p)

    def set_filesystem(self, p, fs):
        return _apol.apol_fs_use_query_t_set_filesystem(self, p, fs)

    def set_behavior(self, p, behavior):
        return _apol.apol_fs_use_query_t_set_behavior(self, p, behavior)

    def set_context(self, p, ctx, range_match):
        return _apol.apol_fs_use_query_t_set_context(self, p, ctx, range_match)
apol_fs_use_query_t_swigregister = _apol.apol_fs_use_query_t_swigregister
apol_fs_use_query_t_swigregister(apol_fs_use_query_t)


def apol_fs_use_render(p, fsuse):
    return _apol.apol_fs_use_render(p, fsuse)
apol_fs_use_render = _apol.apol_fs_use_render
class apol_isid_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_isid_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_isid_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_isid_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_isid_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_isid_query_t_run(self, p)

    def set_name(self, p, name):
        return _apol.apol_isid_query_t_set_name(self, p, name)

    def set_context(self, p, ctx, range_match):
        return _apol.apol_isid_query_t_set_context(self, p, ctx, range_match)
apol_isid_query_t_swigregister = _apol.apol_isid_query_t_swigregister
apol_isid_query_t_swigregister(apol_isid_query_t)

class apol_portcon_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_portcon_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_portcon_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_portcon_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_portcon_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_portcon_query_t_run(self, p)

    def set_protocol(self, p, protocol):
        return _apol.apol_portcon_query_t_set_protocol(self, p, protocol)

    def set_low(self, p, port):
        return _apol.apol_portcon_query_t_set_low(self, p, port)

    def set_high(self, p, port):
        return _apol.apol_portcon_query_t_set_high(self, p, port)

    def set_context(self, p, ctx, range_match):
        return _apol.apol_portcon_query_t_set_context(self, p, ctx, range_match)
apol_portcon_query_t_swigregister = _apol.apol_portcon_query_t_swigregister
apol_portcon_query_t_swigregister(apol_portcon_query_t)


def apol_portcon_render(p, portcon):
    return _apol.apol_portcon_render(p, portcon)
apol_portcon_render = _apol.apol_portcon_render
class apol_netifcon_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_netifcon_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_netifcon_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_netifcon_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_netifcon_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_netifcon_query_t_run(self, p)

    def set_device(self, p, name):
        return _apol.apol_netifcon_query_t_set_device(self, p, name)

    def set_if_context(self, p, ctx, range_match):
        return _apol.apol_netifcon_query_t_set_if_context(self, p, ctx, range_match)

    def set_msg_context(self, p, ctx, range_match):
        return _apol.apol_netifcon_query_t_set_msg_context(self, p, ctx, range_match)
apol_netifcon_query_t_swigregister = _apol.apol_netifcon_query_t_swigregister
apol_netifcon_query_t_swigregister(apol_netifcon_query_t)


def apol_netifcon_render(p, netifcon):
    return _apol.apol_netifcon_render(p, netifcon)
apol_netifcon_render = _apol.apol_netifcon_render
class apol_nodecon_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_nodecon_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_nodecon_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_nodecon_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_nodecon_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_nodecon_query_t_run(self, p)

    def set_protocol(self, p, protocol):
        return _apol.apol_nodecon_query_t_set_protocol(self, p, protocol)

    def set_addr(self, *args):
        return _apol.apol_nodecon_query_t_set_addr(self, *args)

    def set_mask(self, *args):
        return _apol.apol_nodecon_query_t_set_mask(self, *args)

    def set_context(self, p, ctx, range_match):
        return _apol.apol_nodecon_query_t_set_context(self, p, ctx, range_match)
apol_nodecon_query_t_swigregister = _apol.apol_nodecon_query_t_swigregister
apol_nodecon_query_t_swigregister(apol_nodecon_query_t)


def apol_nodecon_render(p, nodecon):
    return _apol.apol_nodecon_render(p, nodecon)
apol_nodecon_render = _apol.apol_nodecon_render
class apol_avrule_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_avrule_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_avrule_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_avrule_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_avrule_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_avrule_query_t_run(self, p)

    def run_syn(self, p):
        return _apol.apol_avrule_query_t_run_syn(self, p)

    def set_rules(self, p, rules):
        return _apol.apol_avrule_query_t_set_rules(self, p, rules)

    def set_source(self, p, name, indirect):
        return _apol.apol_avrule_query_t_set_source(self, p, name, indirect)

    def set_source_component(self, p, component):
        return _apol.apol_avrule_query_t_set_source_component(self, p, component)

    def set_target(self, p, name, indirect):
        return _apol.apol_avrule_query_t_set_target(self, p, name, indirect)

    def set_target_component(self, p, component):
        return _apol.apol_avrule_query_t_set_target_component(self, p, component)

    def append_class(self, p, name):
        return _apol.apol_avrule_query_t_append_class(self, p, name)

    def append_perm(self, p, name):
        return _apol.apol_avrule_query_t_append_perm(self, p, name)

    def set_bool(self, p, name):
        return _apol.apol_avrule_query_t_set_bool(self, p, name)

    def set_enabled(self, p, enabled):
        return _apol.apol_avrule_query_t_set_enabled(self, p, enabled)

    def set_all_perms(self, p, all_perms):
        return _apol.apol_avrule_query_t_set_all_perms(self, p, all_perms)

    def set_source_any(self, p, is_any):
        return _apol.apol_avrule_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_avrule_query_t_set_regex(self, p, regex)
apol_avrule_query_t_swigregister = _apol.apol_avrule_query_t_swigregister
apol_avrule_query_t_swigregister(apol_avrule_query_t)


def apol_avrule_render(policy, rule):
    return _apol.apol_avrule_render(policy, rule)
apol_avrule_render = _apol.apol_avrule_render

def apol_syn_avrule_render(policy, rule):
    return _apol.apol_syn_avrule_render(policy, rule)
apol_syn_avrule_render = _apol.apol_syn_avrule_render

def apol_avrule_to_syn_avrules(p, rule, perms):
    return _apol.apol_avrule_to_syn_avrules(p, rule, perms)
apol_avrule_to_syn_avrules = _apol.apol_avrule_to_syn_avrules

def apol_avrule_list_to_syn_avrules(p, rules, perms):
    return _apol.apol_avrule_list_to_syn_avrules(p, rules, perms)
apol_avrule_list_to_syn_avrules = _apol.apol_avrule_list_to_syn_avrules
class apol_terule_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_terule_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_terule_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_terule_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_terule_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_terule_query_t_run(self, p)

    def run_syn(self, p):
        return _apol.apol_terule_query_t_run_syn(self, p)

    def set_rules(self, p, rules):
        return _apol.apol_terule_query_t_set_rules(self, p, rules)

    def set_source(self, p, name, indirect):
        return _apol.apol_terule_query_t_set_source(self, p, name, indirect)

    def set_source_component(self, p, component):
        return _apol.apol_terule_query_t_set_source_component(self, p, component)

    def set_target(self, p, name, indirect):
        return _apol.apol_terule_query_t_set_target(self, p, name, indirect)

    def set_target_component(self, p, component):
        return _apol.apol_terule_query_t_set_target_component(self, p, component)

    def append_class(self, p, name):
        return _apol.apol_terule_query_t_append_class(self, p, name)

    def set_default(self, p, name):
        return _apol.apol_terule_query_t_set_default(self, p, name)

    def set_bool(self, p, name):
        return _apol.apol_terule_query_t_set_bool(self, p, name)

    def set_enabled(self, p, enabled):
        return _apol.apol_terule_query_t_set_enabled(self, p, enabled)

    def set_source_any(self, p, is_any):
        return _apol.apol_terule_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_terule_query_t_set_regex(self, p, regex)
apol_terule_query_t_swigregister = _apol.apol_terule_query_t_swigregister
apol_terule_query_t_swigregister(apol_terule_query_t)


def apol_terule_render(policy, rule):
    return _apol.apol_terule_render(policy, rule)
apol_terule_render = _apol.apol_terule_render

def apol_syn_terule_render(policy, rule):
    return _apol.apol_syn_terule_render(policy, rule)
apol_syn_terule_render = _apol.apol_syn_terule_render

def apol_terule_to_syn_terules(p, rule):
    return _apol.apol_terule_to_syn_terules(p, rule)
apol_terule_to_syn_terules = _apol.apol_terule_to_syn_terules

def apol_terule_list_to_syn_terules(p, rules):
    return _apol.apol_terule_list_to_syn_terules(p, rules)
apol_terule_list_to_syn_terules = _apol.apol_terule_list_to_syn_terules
class apol_cond_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_cond_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_cond_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_cond_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_cond_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_cond_query_t_run(self, p)

    def set_bool(self, p, name):
        return _apol.apol_cond_query_t_set_bool(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_cond_query_t_set_regex(self, p, regex)
apol_cond_query_t_swigregister = _apol.apol_cond_query_t_swigregister
apol_cond_query_t_swigregister(apol_cond_query_t)


def apol_cond_expr_render(p, cond):
    return _apol.apol_cond_expr_render(p, cond)
apol_cond_expr_render = _apol.apol_cond_expr_render
class apol_role_allow_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_role_allow_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_role_allow_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_role_allow_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_role_allow_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_role_allow_query_t_run(self, p)

    def set_source(self, p, name):
        return _apol.apol_role_allow_query_t_set_source(self, p, name)

    def set_target(self, p, name):
        return _apol.apol_role_allow_query_t_set_target(self, p, name)

    def set_source_any(self, p, is_any):
        return _apol.apol_role_allow_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_role_allow_query_t_set_regex(self, p, regex)
apol_role_allow_query_t_swigregister = _apol.apol_role_allow_query_t_swigregister
apol_role_allow_query_t_swigregister(apol_role_allow_query_t)


def apol_role_allow_render(policy, rule):
    return _apol.apol_role_allow_render(policy, rule)
apol_role_allow_render = _apol.apol_role_allow_render
class apol_role_trans_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_role_trans_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_role_trans_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_role_trans_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_role_trans_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_role_trans_query_t_run(self, p)

    def set_source(self, p, name):
        return _apol.apol_role_trans_query_t_set_source(self, p, name)

    def set_target(self, p, name, indirect):
        return _apol.apol_role_trans_query_t_set_target(self, p, name, indirect)

    def set_default(self, p, name):
        return _apol.apol_role_trans_query_t_set_default(self, p, name)

    def set_source_any(self, p, is_any):
        return _apol.apol_role_trans_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_role_trans_query_t_set_regex(self, p, regex)
apol_role_trans_query_t_swigregister = _apol.apol_role_trans_query_t_swigregister
apol_role_trans_query_t_swigregister(apol_role_trans_query_t)


def apol_role_trans_render(policy, rule):
    return _apol.apol_role_trans_render(policy, rule)
apol_role_trans_render = _apol.apol_role_trans_render
class apol_range_trans_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_range_trans_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_range_trans_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_range_trans_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_range_trans_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_range_trans_query_t_run(self, p)

    def set_source(self, p, name, indirect):
        return _apol.apol_range_trans_query_t_set_source(self, p, name, indirect)

    def set_target(self, p, name, indirect):
        return _apol.apol_range_trans_query_t_set_target(self, p, name, indirect)

    def append_class(self, p, name):
        return _apol.apol_range_trans_query_t_append_class(self, p, name)

    def set_range(self, p, rng, range_match):
        return _apol.apol_range_trans_query_t_set_range(self, p, rng, range_match)

    def set_source_any(self, p, is_any):
        return _apol.apol_range_trans_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_range_trans_query_t_set_regex(self, p, regex)
apol_range_trans_query_t_swigregister = _apol.apol_range_trans_query_t_swigregister
apol_range_trans_query_t_swigregister(apol_range_trans_query_t)


def apol_range_trans_render(policy, rule):
    return _apol.apol_range_trans_render(policy, rule)
apol_range_trans_render = _apol.apol_range_trans_render
class apol_filename_trans_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_filename_trans_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_filename_trans_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_filename_trans_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_filename_trans_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_filename_trans_query_t_run(self, p)

    def set_source(self, p, name, indirect):
        return _apol.apol_filename_trans_query_t_set_source(self, p, name, indirect)

    def set_target(self, p, name, indirect):
        return _apol.apol_filename_trans_query_t_set_target(self, p, name, indirect)

    def append_class(self, p, name):
        return _apol.apol_filename_trans_query_t_append_class(self, p, name)

    def set_default(self, p, name):
        return _apol.apol_filename_trans_query_t_set_default(self, p, name)

    def set_filename(self, p, filename):
        return _apol.apol_filename_trans_query_t_set_filename(self, p, filename)

    def set_source_any(self, p, is_any):
        return _apol.apol_filename_trans_query_t_set_source_any(self, p, is_any)

    def set_regex(self, p, regex):
        return _apol.apol_filename_trans_query_t_set_regex(self, p, regex)
apol_filename_trans_query_t_swigregister = _apol.apol_filename_trans_query_t_swigregister
apol_filename_trans_query_t_swigregister(apol_filename_trans_query_t)


def apol_filename_trans_render(policy, rule):
    return _apol.apol_filename_trans_render(policy, rule)
apol_filename_trans_render = _apol.apol_filename_trans_render
class apol_permissive_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_permissive_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_permissive_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_permissive_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_permissive_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_permissive_query_t_run(self, p)

    def set_name(self, p, name):
        return _apol.apol_permissive_query_t_set_name(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_permissive_query_t_set_regex(self, p, regex)
apol_permissive_query_t_swigregister = _apol.apol_permissive_query_t_swigregister
apol_permissive_query_t_swigregister(apol_permissive_query_t)

class apol_polcap_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_polcap_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_polcap_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_polcap_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_polcap_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_polcap_query_t_run(self, p)

    def set_name(self, p, name):
        return _apol.apol_polcap_query_t_set_name(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_polcap_query_t_set_regex(self, p, regex)
apol_polcap_query_t_swigregister = _apol.apol_polcap_query_t_swigregister
apol_polcap_query_t_swigregister(apol_polcap_query_t)

class apol_typebounds_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_typebounds_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_typebounds_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_typebounds_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_typebounds_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_typebounds_query_t_run(self, p)

    def set_name(self, p, name):
        return _apol.apol_typebounds_query_t_set_name(self, p, name)

    def set_regex(self, p, regex):
        return _apol.apol_typebounds_query_t_set_regex(self, p, regex)
apol_typebounds_query_t_swigregister = _apol.apol_typebounds_query_t_swigregister
apol_typebounds_query_t_swigregister(apol_typebounds_query_t)

class apol_rolebounds_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_rolebounds_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_rolebounds_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_rolebounds_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_rolebounds_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_rolebounds_query_t_run(self, p)
apol_rolebounds_query_t_swigregister = _apol.apol_rolebounds_query_t_swigregister
apol_rolebounds_query_t_swigregister(apol_rolebounds_query_t)

class apol_userbounds_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_userbounds_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_userbounds_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_userbounds_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_userbounds_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_userbounds_query_t_run(self, p)
apol_userbounds_query_t_swigregister = _apol.apol_userbounds_query_t_swigregister
apol_userbounds_query_t_swigregister(apol_userbounds_query_t)

class apol_default_object_query_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_default_object_query_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_default_object_query_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_default_object_query_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_default_object_query_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_default_object_query_t_run(self, p)
apol_default_object_query_t_swigregister = _apol.apol_default_object_query_t_swigregister
apol_default_object_query_t_swigregister(apol_default_object_query_t)


_apol.APOL_DOMAIN_TRANS_DIRECTION_FORWARD_swigconstant(_apol)
APOL_DOMAIN_TRANS_DIRECTION_FORWARD = _apol.APOL_DOMAIN_TRANS_DIRECTION_FORWARD

_apol.APOL_DOMAIN_TRANS_DIRECTION_REVERSE_swigconstant(_apol)
APOL_DOMAIN_TRANS_DIRECTION_REVERSE = _apol.APOL_DOMAIN_TRANS_DIRECTION_REVERSE

_apol.APOL_DOMAIN_TRANS_SEARCH_VALID_swigconstant(_apol)
APOL_DOMAIN_TRANS_SEARCH_VALID = _apol.APOL_DOMAIN_TRANS_SEARCH_VALID

_apol.APOL_DOMAIN_TRANS_SEARCH_INVALID_swigconstant(_apol)
APOL_DOMAIN_TRANS_SEARCH_INVALID = _apol.APOL_DOMAIN_TRANS_SEARCH_INVALID

_apol.APOL_DOMAIN_TRANS_SEARCH_BOTH_swigconstant(_apol)
APOL_DOMAIN_TRANS_SEARCH_BOTH = _apol.APOL_DOMAIN_TRANS_SEARCH_BOTH
class apol_domain_trans_analysis_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_domain_trans_analysis_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_domain_trans_analysis_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_domain_trans_analysis_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_domain_trans_analysis_t
    __del__ = lambda self: None

    def set_direction(self, p, direction):
        return _apol.apol_domain_trans_analysis_t_set_direction(self, p, direction)

    def set_valid(self, p, valid):
        return _apol.apol_domain_trans_analysis_t_set_valid(self, p, valid)

    def set_start_type(self, p, name):
        return _apol.apol_domain_trans_analysis_t_set_start_type(self, p, name)

    def set_result_regex(self, p, regex):
        return _apol.apol_domain_trans_analysis_t_set_result_regex(self, p, regex)

    def append_access_type(self, p, name):
        return _apol.apol_domain_trans_analysis_t_append_access_type(self, p, name)

    def append_class(self, p, class_name):
        return _apol.apol_domain_trans_analysis_t_append_class(self, p, class_name)

    def append_perm(self, p, perm_name):
        return _apol.apol_domain_trans_analysis_t_append_perm(self, p, perm_name)

    def run(self, p):
        return _apol.apol_domain_trans_analysis_t_run(self, p)
apol_domain_trans_analysis_t_swigregister = _apol.apol_domain_trans_analysis_t_swigregister
apol_domain_trans_analysis_t_swigregister(apol_domain_trans_analysis_t)

class apol_domain_trans_result_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_domain_trans_result_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_domain_trans_result_t, name)
    __repr__ = _swig_repr

    def __init__(self, arg2):
        this = _apol.new_apol_domain_trans_result_t(arg2)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_domain_trans_result_t
    __del__ = lambda self: None

    def get_start_type(self):
        return _apol.apol_domain_trans_result_t_get_start_type(self)

    def get_entrypoint_type(self):
        return _apol.apol_domain_trans_result_t_get_entrypoint_type(self)

    def get_end_type(self):
        return _apol.apol_domain_trans_result_t_get_end_type(self)

    def get_is_valid(self):
        return _apol.apol_domain_trans_result_t_get_is_valid(self)

    def get_proc_trans_rules(self):
        return _apol.apol_domain_trans_result_t_get_proc_trans_rules(self)

    def get_entrypoint_rules(self):
        return _apol.apol_domain_trans_result_t_get_entrypoint_rules(self)

    def get_exec_rules(self):
        return _apol.apol_domain_trans_result_t_get_exec_rules(self)

    def get_setexec_rules(self):
        return _apol.apol_domain_trans_result_t_get_setexec_rules(self)

    def get_type_trans_rules(self):
        return _apol.apol_domain_trans_result_t_get_type_trans_rules(self)

    def get_access_rules(self):
        return _apol.apol_domain_trans_result_t_get_access_rules(self)
apol_domain_trans_result_t_swigregister = _apol.apol_domain_trans_result_t_swigregister
apol_domain_trans_result_t_swigregister(apol_domain_trans_result_t)


_apol.APOL_DOMAIN_TRANS_RULE_PROC_TRANS_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_PROC_TRANS = _apol.APOL_DOMAIN_TRANS_RULE_PROC_TRANS

_apol.APOL_DOMAIN_TRANS_RULE_EXEC_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_EXEC = _apol.APOL_DOMAIN_TRANS_RULE_EXEC

_apol.APOL_DOMAIN_TRANS_RULE_EXEC_NO_TRANS_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_EXEC_NO_TRANS = _apol.APOL_DOMAIN_TRANS_RULE_EXEC_NO_TRANS

_apol.APOL_DOMAIN_TRANS_RULE_ENTRYPOINT_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_ENTRYPOINT = _apol.APOL_DOMAIN_TRANS_RULE_ENTRYPOINT

_apol.APOL_DOMAIN_TRANS_RULE_TYPE_TRANS_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_TYPE_TRANS = _apol.APOL_DOMAIN_TRANS_RULE_TYPE_TRANS

_apol.APOL_DOMAIN_TRANS_RULE_SETEXEC_swigconstant(_apol)
APOL_DOMAIN_TRANS_RULE_SETEXEC = _apol.APOL_DOMAIN_TRANS_RULE_SETEXEC

def apol_domain_trans_table_verify_trans(policy, start_dom, ep_type, end_dom):
    return _apol.apol_domain_trans_table_verify_trans(policy, start_dom, ep_type, end_dom)
apol_domain_trans_table_verify_trans = _apol.apol_domain_trans_table_verify_trans

def apol_domain_trans_result_from_void(x):
    return _apol.apol_domain_trans_result_from_void(x)
apol_domain_trans_result_from_void = _apol.apol_domain_trans_result_from_void

_apol.APOL_INFOFLOW_MODE_DIRECT_swigconstant(_apol)
APOL_INFOFLOW_MODE_DIRECT = _apol.APOL_INFOFLOW_MODE_DIRECT

_apol.APOL_INFOFLOW_MODE_TRANS_swigconstant(_apol)
APOL_INFOFLOW_MODE_TRANS = _apol.APOL_INFOFLOW_MODE_TRANS

_apol.APOL_INFOFLOW_IN_swigconstant(_apol)
APOL_INFOFLOW_IN = _apol.APOL_INFOFLOW_IN

_apol.APOL_INFOFLOW_OUT_swigconstant(_apol)
APOL_INFOFLOW_OUT = _apol.APOL_INFOFLOW_OUT

_apol.APOL_INFOFLOW_BOTH_swigconstant(_apol)
APOL_INFOFLOW_BOTH = _apol.APOL_INFOFLOW_BOTH

_apol.APOL_INFOFLOW_EITHER_swigconstant(_apol)
APOL_INFOFLOW_EITHER = _apol.APOL_INFOFLOW_EITHER
class apol_infoflow_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_infoflow_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_infoflow_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_infoflow_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_infoflow_t
    __del__ = lambda self: None

    def extract_graph(self):
        return _apol.apol_infoflow_t_extract_graph(self)

    def extract_result_vector(self):
        return _apol.apol_infoflow_t_extract_result_vector(self)
apol_infoflow_t_swigregister = _apol.apol_infoflow_t_swigregister
apol_infoflow_t_swigregister(apol_infoflow_t)

class apol_infoflow_analysis_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_infoflow_analysis_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_infoflow_analysis_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_infoflow_analysis_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_infoflow_analysis_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_infoflow_analysis_t_run(self, p)

    def set_mode(self, p, mode):
        return _apol.apol_infoflow_analysis_t_set_mode(self, p, mode)

    def set_dir(self, p, direction):
        return _apol.apol_infoflow_analysis_t_set_dir(self, p, direction)

    def set_type(self, p, name):
        return _apol.apol_infoflow_analysis_t_set_type(self, p, name)

    def append_intermediate(self, p, name):
        return _apol.apol_infoflow_analysis_t_append_intermediate(self, p, name)

    def append_class_perm(self, p, class_name, perm_name):
        return _apol.apol_infoflow_analysis_t_append_class_perm(self, p, class_name, perm_name)

    def set_min_weight(self, p, weight):
        return _apol.apol_infoflow_analysis_t_set_min_weight(self, p, weight)

    def set_result_regex(self, p, regex):
        return _apol.apol_infoflow_analysis_t_set_result_regex(self, p, regex)
apol_infoflow_analysis_t_swigregister = _apol.apol_infoflow_analysis_t_swigregister
apol_infoflow_analysis_t_swigregister(apol_infoflow_analysis_t)

class apol_infoflow_graph_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_infoflow_graph_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_infoflow_graph_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_infoflow_graph_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_infoflow_graph_t
    __del__ = lambda self: None

    def do_more(self, p, type):
        return _apol.apol_infoflow_graph_t_do_more(self, p, type)

    def trans_further_prepare(self, p, start_type, end_type):
        return _apol.apol_infoflow_graph_t_trans_further_prepare(self, p, start_type, end_type)

    def trans_further_next(self, p, v):
        return _apol.apol_infoflow_graph_t_trans_further_next(self, p, v)
apol_infoflow_graph_t_swigregister = _apol.apol_infoflow_graph_t_swigregister
apol_infoflow_graph_t_swigregister(apol_infoflow_graph_t)

class apol_infoflow_result_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_infoflow_result_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_infoflow_result_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_infoflow_result_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_infoflow_result_t
    __del__ = lambda self: None

    def get_dir(self):
        return _apol.apol_infoflow_result_t_get_dir(self)

    def get_start_type(self):
        return _apol.apol_infoflow_result_t_get_start_type(self)

    def get_end_type(self):
        return _apol.apol_infoflow_result_t_get_end_type(self)

    def get_length(self):
        return _apol.apol_infoflow_result_t_get_length(self)

    def get_steps(self):
        return _apol.apol_infoflow_result_t_get_steps(self)
apol_infoflow_result_t_swigregister = _apol.apol_infoflow_result_t_swigregister
apol_infoflow_result_t_swigregister(apol_infoflow_result_t)


def apol_infoflow_result_from_void(x):
    return _apol.apol_infoflow_result_from_void(x)
apol_infoflow_result_from_void = _apol.apol_infoflow_result_from_void
class apol_infoflow_step_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_infoflow_step_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_infoflow_step_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_infoflow_step_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_infoflow_step_t
    __del__ = lambda self: None

    def get_start_type(self):
        return _apol.apol_infoflow_step_t_get_start_type(self)

    def get_end_type(self):
        return _apol.apol_infoflow_step_t_get_end_type(self)

    def get_weight(self):
        return _apol.apol_infoflow_step_t_get_weight(self)

    def get_rules(self):
        return _apol.apol_infoflow_step_t_get_rules(self)
apol_infoflow_step_t_swigregister = _apol.apol_infoflow_step_t_swigregister
apol_infoflow_step_t_swigregister(apol_infoflow_step_t)


def apol_infoflow_step_from_void(x):
    return _apol.apol_infoflow_step_from_void(x)
apol_infoflow_step_from_void = _apol.apol_infoflow_step_from_void

_apol.APOL_RELABEL_DIR_TO_swigconstant(_apol)
APOL_RELABEL_DIR_TO = _apol.APOL_RELABEL_DIR_TO

_apol.APOL_RELABEL_DIR_FROM_swigconstant(_apol)
APOL_RELABEL_DIR_FROM = _apol.APOL_RELABEL_DIR_FROM

_apol.APOL_RELABEL_DIR_BOTH_swigconstant(_apol)
APOL_RELABEL_DIR_BOTH = _apol.APOL_RELABEL_DIR_BOTH

_apol.APOL_RELABEL_DIR_SUBJECT_swigconstant(_apol)
APOL_RELABEL_DIR_SUBJECT = _apol.APOL_RELABEL_DIR_SUBJECT
class apol_relabel_analysis_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_relabel_analysis_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_relabel_analysis_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_relabel_analysis_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_relabel_analysis_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_relabel_analysis_t_run(self, p)

    def set_dir(self, p, direction):
        return _apol.apol_relabel_analysis_t_set_dir(self, p, direction)

    def set_type(self, p, name):
        return _apol.apol_relabel_analysis_t_set_type(self, p, name)

    def append_class(self, p, name):
        return _apol.apol_relabel_analysis_t_append_class(self, p, name)

    def append_subject(self, p, name):
        return _apol.apol_relabel_analysis_t_append_subject(self, p, name)

    def set_result_regex(self, p, regex):
        return _apol.apol_relabel_analysis_t_set_result_regex(self, p, regex)
apol_relabel_analysis_t_swigregister = _apol.apol_relabel_analysis_t_swigregister
apol_relabel_analysis_t_swigregister(apol_relabel_analysis_t)

class apol_relabel_result_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_relabel_result_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_relabel_result_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_relabel_result_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_relabel_result_t
    __del__ = lambda self: None

    def get_to(self):
        return _apol.apol_relabel_result_t_get_to(self)

    def get_from(self):
        return _apol.apol_relabel_result_t_get_from(self)

    def get_both(self):
        return _apol.apol_relabel_result_t_get_both(self)

    def get_result_type(self):
        return _apol.apol_relabel_result_t_get_result_type(self)
apol_relabel_result_t_swigregister = _apol.apol_relabel_result_t_swigregister
apol_relabel_result_t_swigregister(apol_relabel_result_t)


def apol_relabel_result_from_void(x):
    return _apol.apol_relabel_result_from_void(x)
apol_relabel_result_from_void = _apol.apol_relabel_result_from_void
class apol_relabel_result_pair_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_relabel_result_pair_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_relabel_result_pair_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_relabel_result_pair_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_relabel_result_pair_t
    __del__ = lambda self: None

    def get_ruleA(self):
        return _apol.apol_relabel_result_pair_t_get_ruleA(self)

    def get_ruleB(self):
        return _apol.apol_relabel_result_pair_t_get_ruleB(self)

    def get_intermediate_type(self):
        return _apol.apol_relabel_result_pair_t_get_intermediate_type(self)
apol_relabel_result_pair_t_swigregister = _apol.apol_relabel_result_pair_t_swigregister
apol_relabel_result_pair_t_swigregister(apol_relabel_result_pair_t)


def apol_relabel_result_pair_from_void(x):
    return _apol.apol_relabel_result_pair_from_void(x)
apol_relabel_result_pair_from_void = _apol.apol_relabel_result_pair_from_void

_apol.APOL_TYPES_RELATION_COMMON_ATTRIBS_swigconstant(_apol)
APOL_TYPES_RELATION_COMMON_ATTRIBS = _apol.APOL_TYPES_RELATION_COMMON_ATTRIBS

_apol.APOL_TYPES_RELATION_COMMON_ROLES_swigconstant(_apol)
APOL_TYPES_RELATION_COMMON_ROLES = _apol.APOL_TYPES_RELATION_COMMON_ROLES

_apol.APOL_TYPES_RELATION_COMMON_USERS_swigconstant(_apol)
APOL_TYPES_RELATION_COMMON_USERS = _apol.APOL_TYPES_RELATION_COMMON_USERS

_apol.APOL_TYPES_RELATION_SIMILAR_ACCESS_swigconstant(_apol)
APOL_TYPES_RELATION_SIMILAR_ACCESS = _apol.APOL_TYPES_RELATION_SIMILAR_ACCESS

_apol.APOL_TYPES_RELATION_DISSIMILAR_ACCESS_swigconstant(_apol)
APOL_TYPES_RELATION_DISSIMILAR_ACCESS = _apol.APOL_TYPES_RELATION_DISSIMILAR_ACCESS

_apol.APOL_TYPES_RELATION_ALLOW_RULES_swigconstant(_apol)
APOL_TYPES_RELATION_ALLOW_RULES = _apol.APOL_TYPES_RELATION_ALLOW_RULES

_apol.APOL_TYPES_RELATION_TYPE_RULES_swigconstant(_apol)
APOL_TYPES_RELATION_TYPE_RULES = _apol.APOL_TYPES_RELATION_TYPE_RULES

_apol.APOL_TYPES_RELATION_DOMAIN_TRANS_AB_swigconstant(_apol)
APOL_TYPES_RELATION_DOMAIN_TRANS_AB = _apol.APOL_TYPES_RELATION_DOMAIN_TRANS_AB

_apol.APOL_TYPES_RELATION_DOMAIN_TRANS_BA_swigconstant(_apol)
APOL_TYPES_RELATION_DOMAIN_TRANS_BA = _apol.APOL_TYPES_RELATION_DOMAIN_TRANS_BA

_apol.APOL_TYPES_RELATION_DIRECT_FLOW_swigconstant(_apol)
APOL_TYPES_RELATION_DIRECT_FLOW = _apol.APOL_TYPES_RELATION_DIRECT_FLOW

_apol.APOL_TYPES_RELATION_TRANS_FLOW_AB_swigconstant(_apol)
APOL_TYPES_RELATION_TRANS_FLOW_AB = _apol.APOL_TYPES_RELATION_TRANS_FLOW_AB

_apol.APOL_TYPES_RELATION_TRANS_FLOW_BA_swigconstant(_apol)
APOL_TYPES_RELATION_TRANS_FLOW_BA = _apol.APOL_TYPES_RELATION_TRANS_FLOW_BA
class apol_types_relation_analysis_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_types_relation_analysis_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_types_relation_analysis_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_types_relation_analysis_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_types_relation_analysis_t
    __del__ = lambda self: None

    def run(self, p):
        return _apol.apol_types_relation_analysis_t_run(self, p)

    def set_first_type(self, p, name):
        return _apol.apol_types_relation_analysis_t_set_first_type(self, p, name)

    def set_other_type(self, p, name):
        return _apol.apol_types_relation_analysis_t_set_other_type(self, p, name)

    def set_analyses(self, p, analyses):
        return _apol.apol_types_relation_analysis_t_set_analyses(self, p, analyses)
apol_types_relation_analysis_t_swigregister = _apol.apol_types_relation_analysis_t_swigregister
apol_types_relation_analysis_t_swigregister(apol_types_relation_analysis_t)

class apol_types_relation_result_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_types_relation_result_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_types_relation_result_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_types_relation_result_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_types_relation_result_t
    __del__ = lambda self: None

    def get_attributes(self):
        return _apol.apol_types_relation_result_t_get_attributes(self)

    def get_roles(self):
        return _apol.apol_types_relation_result_t_get_roles(self)

    def get_users(self):
        return _apol.apol_types_relation_result_t_get_users(self)

    def get_similar_first(self):
        return _apol.apol_types_relation_result_t_get_similar_first(self)

    def get_similar_other(self):
        return _apol.apol_types_relation_result_t_get_similar_other(self)

    def get_dissimilar_first(self):
        return _apol.apol_types_relation_result_t_get_dissimilar_first(self)

    def get_dissimilar_other(self):
        return _apol.apol_types_relation_result_t_get_dissimilar_other(self)

    def get_allowrules(self):
        return _apol.apol_types_relation_result_t_get_allowrules(self)

    def get_typerules(self):
        return _apol.apol_types_relation_result_t_get_typerules(self)

    def get_directflows(self):
        return _apol.apol_types_relation_result_t_get_directflows(self)

    def get_transflowsAB(self):
        return _apol.apol_types_relation_result_t_get_transflowsAB(self)

    def get_transflowsBA(self):
        return _apol.apol_types_relation_result_t_get_transflowsBA(self)

    def get_domainsAB(self):
        return _apol.apol_types_relation_result_t_get_domainsAB(self)

    def get_domainsBA(self):
        return _apol.apol_types_relation_result_t_get_domainsBA(self)
apol_types_relation_result_t_swigregister = _apol.apol_types_relation_result_t_swigregister
apol_types_relation_result_t_swigregister(apol_types_relation_result_t)

class apol_types_relation_access_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apol_types_relation_access_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apol_types_relation_access_t, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _apol.new_apol_types_relation_access_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _apol.delete_apol_types_relation_access_t
    __del__ = lambda self: None

    def get_type(self):
        return _apol.apol_types_relation_access_t_get_type(self)

    def get_rules(self):
        return _apol.apol_types_relation_access_t_get_rules(self)
apol_types_relation_access_t_swigregister = _apol.apol_types_relation_access_t_swigregister
apol_types_relation_access_t_swigregister(apol_types_relation_access_t)


def apol_types_relation_access_from_void(x):
    return _apol.apol_types_relation_access_from_void(x)
apol_types_relation_access_from_void = _apol.apol_types_relation_access_from_void
# This file is compatible with both classic and new-style classes.


