# Auto-generated. Do not edit.
from opendp._convert import *
from opendp._lib import *
from opendp.mod import *
from opendp.typing import *
__all__ = [
"_domain_free",
"atom_domain",
"domain_carrier_type",
"domain_debug",
"domain_type",
"map_domain",
"member",
"option_domain",
"vector_domain"
]
@versioned
def _domain_free(
this
):
"""Internal function. Free the memory associated with `this`.
[_domain_free in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn._domain_free.html)
:param this:
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = this
# Call library function.
lib_function = lib.opendp_domains___domain_free
lib_function.argtypes = [Domain]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_void_p))
return output
[docs]
@versioned
def atom_domain(
bounds: Any = None,
nullable: bool = False,
T: RuntimeTypeDescriptor = None
):
"""Construct an instance of `AtomDomain`.
[atom_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.atom_domain.html)
:param bounds:
:type bounds: Any
:param nullable:
:type nullable: bool
:param T: The type of the atom.
:type T: :py:ref:`RuntimeTypeDescriptor`
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=get_first(bounds))
# Convert arguments to c types.
c_bounds = py_to_c(bounds, c_type=AnyObjectPtr, type_name=RuntimeType(origin='Option', args=[RuntimeType(origin='Tuple', args=[T, T])]))
c_nullable = py_to_c(nullable, c_type=ctypes.c_bool, type_name=bool)
c_T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
lib_function = lib.opendp_domains__atom_domain
lib_function.argtypes = [AnyObjectPtr, ctypes.c_bool, ctypes.c_char_p]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_bounds, c_nullable, c_T), Domain))
return output
[docs]
@versioned
def domain_carrier_type(
this
) -> str:
"""Get the carrier type of a `domain`.
[domain_carrier_type in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.domain_carrier_type.html)
:param this: The domain to retrieve the carrier type from.
:rtype: str
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = py_to_c(this, c_type=Domain, type_name=None)
# Call library function.
lib_function = lib.opendp_domains__domain_carrier_type
lib_function.argtypes = [Domain]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_char_p))
return output
[docs]
@versioned
def domain_debug(
this
) -> str:
"""Debug a `domain`.
[domain_debug in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.domain_debug.html)
:param this: The domain to debug (stringify).
:rtype: str
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = py_to_c(this, c_type=Domain, type_name=None)
# Call library function.
lib_function = lib.opendp_domains__domain_debug
lib_function.argtypes = [Domain]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_char_p))
return output
[docs]
@versioned
def domain_type(
this
) -> str:
"""Get the type of a `domain`.
[domain_type in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.domain_type.html)
:param this: The domain to retrieve the type from.
:rtype: str
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = py_to_c(this, c_type=Domain, type_name=None)
# Call library function.
lib_function = lib.opendp_domains__domain_type
lib_function.argtypes = [Domain]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_char_p))
return output
[docs]
@versioned
def map_domain(
key_domain,
value_domain
):
"""Construct an instance of `MapDomain`.
[map_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.map_domain.html)
:param key_domain: domain of keys in the hashmap
:param value_domain: domain of values in the hashmap
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_key_domain = py_to_c(key_domain, c_type=Domain, type_name=AnyDomain)
c_value_domain = py_to_c(value_domain, c_type=Domain, type_name=AnyDomain)
# Call library function.
lib_function = lib.opendp_domains__map_domain
lib_function.argtypes = [Domain, Domain]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_key_domain, c_value_domain), Domain))
return output
[docs]
@versioned
def member(
this: Domain,
val: Any
):
"""Check membership in a `domain`.
[member in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.member.html)
:param this: The domain to check membership in.
:type this: Domain
:param val: A potential element of the domain.
:type val: Any
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = py_to_c(this, c_type=Domain, type_name=AnyDomain)
c_val = py_to_c(val, c_type=AnyObjectPtr, type_name=domain_carrier_type(this))
# Call library function.
lib_function = lib.opendp_domains__member
lib_function.argtypes = [Domain, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this, c_val), BoolPtr))
return output
[docs]
@versioned
def option_domain(
element_domain,
D: RuntimeTypeDescriptor = None
):
"""Construct an instance of `OptionDomain`.
[option_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.option_domain.html)
:param element_domain:
:param D: The type of the inner domain.
:type D: :py:ref:`RuntimeTypeDescriptor`
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
D = RuntimeType.parse_or_infer(type_name=D, public_example=element_domain)
# Convert arguments to c types.
c_element_domain = py_to_c(element_domain, c_type=Domain, type_name=D)
c_D = py_to_c(D, c_type=ctypes.c_char_p)
# Call library function.
lib_function = lib.opendp_domains__option_domain
lib_function.argtypes = [Domain, ctypes.c_char_p]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_element_domain, c_D), Domain))
return output
[docs]
@versioned
def vector_domain(
atom_domain,
size: Any = None
):
"""Construct an instance of `VectorDomain`.
[vector_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/domains/fn.vector_domain.html)
:param atom_domain: The inner domain.
:param size:
:type size: Any
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_atom_domain = py_to_c(atom_domain, c_type=Domain, type_name=AnyDomain)
c_size = py_to_c(size, c_type=AnyObjectPtr, type_name=RuntimeType(origin='Option', args=[i32]))
# Call library function.
lib_function = lib.opendp_domains__vector_domain
lib_function.argtypes = [Domain, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_atom_domain, c_size), Domain))
return output
